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

refactor: move more methods onto the sql struct

Browse Source
This commit is contained in:
dignifiedquire
2019-07-15 00:33:02 +02:00
parent 668c647fdd
commit cdfc8c6fa7
24 changed files with 562 additions and 584 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
examples/repl/cmdline.rs
View File

@@ -125,15 +125,12 @@ 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);
sql::set_config( context
context, .sql
&context.sql, .set_config(context, "import_spec", Some(as_str(real_spec)));
"import_spec",
Some(as_str(real_spec)),
);
current_block = 7149356873433890176; current_block = 7149356873433890176;
} else { } else {
let rs = sql::get_config(context, &context.sql, "import_spec", None); let rs = context.sql.get_config(context, "import_spec", None);
if rs.is_none() { if rs.is_none() {
error!(context, 0, "Import: No file or folder given."); error!(context, 0, "Import: No file or folder given.");
current_block = 8522321847195001863; current_block = 8522321847195001863;

17
src/config.rs
View File

@@ -8,7 +8,6 @@ use crate::context::Context;
use crate::dc_job::*; use crate::dc_job::*;
use crate::dc_stock::*; use crate::dc_stock::*;
use crate::dc_tools::*; use crate::dc_tools::*;
use crate::sql;
use crate::x::*; use crate::x::*;
/// The available configuration keys. /// The available configuration keys.
@@ -83,7 +82,7 @@ pub fn get(context: &Context, key: impl AsRef<str>) -> String {
Ok(config_key) => { Ok(config_key) => {
let value = match config_key { let value = match config_key {
Config::Selfavatar => { Config::Selfavatar => {
let rel_path = sql::get_config(context, &context.sql, key, None); let rel_path = context.sql.get_config(context, key, None);
rel_path.map(|p| { rel_path.map(|p| {
let v = unsafe { dc_get_abs_path(context, to_cstring(p).as_ptr()) }; let v = unsafe { dc_get_abs_path(context, to_cstring(p).as_ptr()) };
let r = to_string(v); let r = to_string(v);
@@ -91,7 +90,7 @@ pub fn get(context: &Context, key: impl AsRef<str>) -> String {
r r
}) })
} }
_ => sql::get_config(context, &context.sql, key, None), _ => context.sql.get_config(context, key, None),
}; };
if value.is_some() { if value.is_some() {
@@ -151,20 +150,20 @@ pub fn set(context: &Context, key: impl AsRef<str>, value: Option<&str>) -> libc
Ok(Config::Selfavatar) if value.is_some() => { Ok(Config::Selfavatar) if value.is_some() => {
let mut rel_path = unsafe { dc_strdup(to_cstring(value.unwrap()).as_ptr()) }; 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) } { 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))); ret = context.sql.set_config(context, key, Some(as_str(rel_path)));
} }
unsafe { free(rel_path as *mut libc::c_void) }; unsafe { free(rel_path as *mut libc::c_void) };
} }
Ok(Config::InboxWatch) => { Ok(Config::InboxWatch) => {
ret = sql::set_config(context, &context.sql, key, value); ret = context.sql.set_config(context, key, value);
unsafe { dc_interrupt_imap_idle(context) }; unsafe { dc_interrupt_imap_idle(context) };
} }
Ok(Config::SentboxWatch) => { Ok(Config::SentboxWatch) => {
ret = sql::set_config(context, &context.sql, key, value); ret = context.sql.set_config(context, key, value);
unsafe { dc_interrupt_sentbox_idle(context) }; unsafe { dc_interrupt_sentbox_idle(context) };
} }
Ok(Config::MvboxWatch) => { Ok(Config::MvboxWatch) => {
ret = sql::set_config(context, &context.sql, key, value); ret = context.sql.set_config(context, key, value);
unsafe { dc_interrupt_mvbox_idle(context) }; unsafe { dc_interrupt_mvbox_idle(context) };
} }
Ok(Config::Selfstatus) => { Ok(Config::Selfstatus) => {
@@ -175,11 +174,11 @@ pub fn set(context: &Context, key: impl AsRef<str>, value: Option<&str>) -> libc
value value
}; };
ret = sql::set_config(context, &context.sql, key, val); ret = context.sql.set_config(context, key, val);
unsafe { free(def as *mut libc::c_void) }; unsafe { free(def as *mut libc::c_void) };
} }
Ok(_) => { Ok(_) => {
ret = sql::set_config(context, &context.sql, key, value); ret = context.sql.set_config(context, key, value);
} }
Err(_) => {} Err(_) => {}
} }

60
src/context.rs
View File

@@ -15,7 +15,7 @@ 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::sql::Sql;
use crate::types::*; use crate::types::*;
use crate::x::*; use crate::x::*;
@@ -260,7 +260,7 @@ unsafe fn cb_set_config(context: &Context, key: *const libc::c_char, value: *con
} else { } else {
Some(as_str(value)) Some(as_str(value))
}; };
sql::set_config(context, &context.sql, as_str(key), v); context.sql.set_config(context, as_str(key), v);
} }
/* * /* *
@@ -280,7 +280,7 @@ unsafe fn cb_get_config(
} else { } else {
Some(as_str(def)) Some(as_str(def))
}; };
let res = sql::get_config(context, &context.sql, as_str(key), d); let res = context.sql.get_config(context, as_str(key), d);
if let Some(res) = res { if let Some(res) = res {
strdup(to_cstring(res).as_ptr()) strdup(to_cstring(res).as_ptr())
} else { } else {
@@ -376,27 +376,25 @@ pub unsafe fn dc_get_info(context: &Context) -> *mut libc::c_char {
let unset = "0"; let unset = "0";
let l = dc_loginparam_read(context, &context.sql, ""); let l = dc_loginparam_read(context, &context.sql, "");
let l2 = dc_loginparam_read(context, &context.sql, "configured_"); let l2 = dc_loginparam_read(context, &context.sql, "configured_");
let displayname = sql::get_config(context, &context.sql, "displayname", None); let displayname = context.sql.get_config(context, "displayname", None);
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 = sql::get_config_int(context, &context.sql, "configured", 0); let is_configured = context.sql.get_config_int(context, "configured", 0);
let dbversion = sql::get_config_int(context, &context.sql, "dbversion", 0); let dbversion = context.sql.get_config_int(context, "dbversion", 0);
let e2ee_enabled = sql::get_config_int(context, &context.sql, "e2ee_enabled", 1); let e2ee_enabled = context.sql.get_config_int(context, "e2ee_enabled", 1);
let mdns_enabled = sql::get_config_int(context, &context.sql, "mdns_enabled", 1); let mdns_enabled = context.sql.get_config_int(context, "mdns_enabled", 1);
let prv_key_cnt: Option<isize> = sql::query_row( let prv_key_cnt: Option<isize> = context.sql.query_row_col(
context, context,
&context.sql,
"SELECT COUNT(*) FROM keypairs;", "SELECT COUNT(*) FROM keypairs;",
rusqlite::NO_PARAMS, rusqlite::NO_PARAMS,
0, 0,
); );
let pub_key_cnt: Option<isize> = sql::query_row( let pub_key_cnt: Option<isize> = context.sql.query_row_col(
context, context,
&context.sql,
"SELECT COUNT(*) FROM acpeerstates;", "SELECT COUNT(*) FROM acpeerstates;",
rusqlite::NO_PARAMS, rusqlite::NO_PARAMS,
0, 0,
@@ -411,23 +409,19 @@ pub unsafe fn dc_get_info(context: &Context) -> *mut libc::c_char {
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 = sql::get_config_int(context, &context.sql, "inbox_watch", 1); let inbox_watch = context.sql.get_config_int(context, "inbox_watch", 1);
let sentbox_watch = sql::get_config_int(context, &context.sql, "sentbox_watch", 1); let sentbox_watch = context.sql.get_config_int(context, "sentbox_watch", 1);
let mvbox_watch = sql::get_config_int(context, &context.sql, "mvbox_watch", 1); let mvbox_watch = context.sql.get_config_int(context, "mvbox_watch", 1);
let mvbox_move = sql::get_config_int(context, &context.sql, "mvbox_move", 1); let mvbox_move = context.sql.get_config_int(context, "mvbox_move", 1);
let folders_configured = sql::get_config_int(context, &context.sql, "folders_configured", 0); let folders_configured = context.sql.get_config_int(context, "folders_configured", 0);
let configured_sentbox_folder = sql::get_config( let configured_sentbox_folder =
context, context
&context.sql, .sql
"configured_sentbox_folder", .get_config(context, "configured_sentbox_folder", Some("<unset>"));
Some("<unset>"), let configured_mvbox_folder =
); context
let configured_mvbox_folder = sql::get_config( .sql
context, .get_config(context, "configured_mvbox_folder", Some("<unset>"));
&context.sql,
"configured_mvbox_folder",
Some("<unset>"),
);
let res = format!( let res = format!(
"deltachat_core_version=v{}\n\ "deltachat_core_version=v{}\n\
@@ -589,7 +583,9 @@ pub fn dc_is_inbox(_context: &Context, folder_name: impl AsRef<str>) -> bool {
} }
pub fn dc_is_sentbox(context: &Context, folder_name: impl AsRef<str>) -> bool { 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); let sentbox_name = context
.sql
.get_config(context, "configured_sentbox_folder", None);
if let Some(name) = sentbox_name { if let Some(name) = sentbox_name {
name == folder_name.as_ref() name == folder_name.as_ref()
} else { } else {
@@ -598,7 +594,9 @@ pub fn dc_is_sentbox(context: &Context, folder_name: impl AsRef<str>) -> bool {
} }
pub fn dc_is_mvbox(context: &Context, folder_name: impl AsRef<str>) -> bool { pub fn dc_is_mvbox(context: &Context, folder_name: impl AsRef<str>) -> bool {
let mvbox_name = sql::get_config(context, &context.sql, "configured_mvbox_folder", None); let mvbox_name = context
.sql
.get_config(context, "configured_mvbox_folder", None);
if let Some(name) = mvbox_name { if let Some(name) = mvbox_name {
name == folder_name.as_ref() name == folder_name.as_ref()

129
src/dc_chat.rs
View File

@@ -484,7 +484,7 @@ unsafe fn prepare_msg_raw(
"Cannot send message; self not in group.", "Cannot send message; self not in group.",
); );
} else { } else {
let from = sql::get_config(context, &context.sql, "configured_addr", None); let from = context.sql.get_config(context, "configured_addr", None);
if from.is_none() { if from.is_none() {
error!(context, 0, "Cannot send message, not configured.",); error!(context, 0, "Cannot send message, not configured.",);
} else { } else {
@@ -499,9 +499,8 @@ unsafe fn prepare_msg_raw(
); );
if (*chat).type_0 == 100 { if (*chat).type_0 == 100 {
if let Some(id) = sql::query_row( if let Some(id) = context.sql.query_row_col(
context, context,
&context.sql,
"SELECT contact_id FROM chats_contacts WHERE chat_id=?;", "SELECT contact_id FROM chats_contacts WHERE chat_id=?;",
params![(*chat).id as i32], params![(*chat).id as i32],
0, 0,
@@ -534,7 +533,7 @@ unsafe fn prepare_msg_raw(
so that E2EE is no longer available at a later point (reset, changed settings), so that E2EE is no longer available at a later point (reset, changed settings),
we do not send the message out at all */ we do not send the message out at all */
do_guarantee_e2ee = 0; do_guarantee_e2ee = 0;
e2ee_enabled = sql::get_config_int(context, &context.sql, "e2ee_enabled", 1); e2ee_enabled = context.sql.get_config_int(context, "e2ee_enabled", 1);
if 0 != e2ee_enabled && dc_param_get_int((*msg).param, 'u' as i32, 0) == 0 { if 0 != e2ee_enabled && dc_param_get_int((*msg).param, 'u' as i32, 0) == 0 {
let mut can_encrypt: libc::c_int = 1; let mut can_encrypt: libc::c_int = 1;
let mut all_mutual: libc::c_int = 1; let mut all_mutual: libc::c_int = 1;
@@ -799,9 +798,8 @@ unsafe fn last_msg_in_chat_encrypted(
chat_id: uint32_t, chat_id: uint32_t,
) -> libc::c_int { ) -> libc::c_int {
let mut last_is_encrypted: libc::c_int = 0i32; let mut last_is_encrypted: libc::c_int = 0i32;
let packed: Option<String> = sql::query_row( let packed: Option<String> = sql.query_row_col(
context, context,
sql,
"SELECT param \ "SELECT param \
FROM msgs WHERE timestamp=(SELECT MAX(timestamp) FROM msgs WHERE chat_id=?) \ FROM msgs WHERE timestamp=(SELECT MAX(timestamp) FROM msgs WHERE chat_id=?) \
ORDER BY id DESC;", ORDER BY id DESC;",
@@ -1012,14 +1010,15 @@ unsafe fn set_draft_raw(context: &Context, chat_id: uint32_t, msg: *mut dc_msg_t
} }
fn get_draft_msg_id(context: &Context, chat_id: u32) -> u32 { fn get_draft_msg_id(context: &Context, chat_id: u32) -> u32 {
let draft_msg_id: i32 = sql::query_row( let draft_msg_id: i32 = context
context, .sql
&context.sql, .query_row_col(
"SELECT id FROM msgs WHERE chat_id=? AND state=?;", context,
params![chat_id as i32, 19], "SELECT id FROM msgs WHERE chat_id=? AND state=?;",
0, params![chat_id as i32, 19],
) 0,
.unwrap_or_default(); )
.unwrap_or_default();
draft_msg_id as u32 draft_msg_id as u32
} }
@@ -1076,7 +1075,7 @@ pub unsafe fn dc_get_chat_msgs(
}; };
let success = if chat_id == 1 { let success = if chat_id == 1 {
let show_emails = sql::get_config_int(context, &context.sql, "show_emails", 0); let show_emails = context.sql.get_config_int(context, "show_emails", 0);
context.sql.query_map( context.sql.query_map(
"SELECT m.id, m.timestamp FROM msgs m \ "SELECT m.id, m.timestamp FROM msgs m \
LEFT JOIN chats ON m.chat_id=chats.id \ LEFT JOIN chats ON m.chat_id=chats.id \
@@ -1125,28 +1124,30 @@ pub unsafe fn dc_get_chat_msgs(
} }
pub fn dc_get_msg_cnt(context: &Context, chat_id: u32) -> libc::c_int { pub fn dc_get_msg_cnt(context: &Context, chat_id: u32) -> libc::c_int {
sql::query_row( context
context, .sql
&context.sql, .query_row_col(
"SELECT COUNT(*) FROM msgs WHERE chat_id=?;", context,
params![chat_id as i32], "SELECT COUNT(*) FROM msgs WHERE chat_id=?;",
0, params![chat_id as i32],
) 0,
.unwrap_or_default() )
.unwrap_or_default()
} }
pub fn dc_get_fresh_msg_cnt(context: &Context, chat_id: u32) -> libc::c_int { pub fn dc_get_fresh_msg_cnt(context: &Context, chat_id: u32) -> libc::c_int {
sql::query_row( context
context, .sql
&context.sql, .query_row_col(
"SELECT COUNT(*) FROM msgs \ context,
WHERE state=10 \ "SELECT COUNT(*) FROM msgs \
AND hidden=0 \ WHERE state=10 \
AND chat_id=?;", AND hidden=0 \
params![chat_id as i32], AND chat_id=?;",
0, params![chat_id as i32],
) 0,
.unwrap_or_default() )
.unwrap_or_default()
} }
pub fn dc_marknoticed_chat(context: &Context, chat_id: u32) -> bool { pub fn dc_marknoticed_chat(context: &Context, chat_id: u32) -> bool {
@@ -1518,7 +1519,9 @@ pub unsafe fn dc_add_contact_to_chat_ex(
dc_param_set((*chat).param, 'U' as i32, 0 as *const libc::c_char); dc_param_set((*chat).param, 'U' as i32, 0 as *const libc::c_char);
dc_chat_update_param(chat); dc_chat_update_param(chat);
} }
let self_addr = sql::get_config(context, &context.sql, "configured_addr", Some("")) let self_addr = context
.sql
.get_config(context, "configured_addr", Some(""))
.unwrap_or_default(); .unwrap_or_default();
if as_str((*contact).addr) != &self_addr { if as_str((*contact).addr) != &self_addr {
// ourself is added using DC_CONTACT_ID_SELF, do not add it explicitly. // ourself is added using DC_CONTACT_ID_SELF, do not add it explicitly.
@@ -2039,16 +2042,18 @@ pub unsafe fn dc_chat_get_subtitle(chat: *const Chat) -> *mut libc::c_char {
if (*chat).type_0 == 100 && 0 != dc_param_exists((*chat).param, 'K' as i32) { if (*chat).type_0 == 100 && 0 != dc_param_exists((*chat).param, 'K' as i32) {
ret = dc_stock_str((*chat).context, 50) ret = dc_stock_str((*chat).context, 50)
} else if (*chat).type_0 == 100 { } else if (*chat).type_0 == 100 {
let ret_raw: String = sql::query_row( let ret_raw: String = (*chat)
(*chat).context, .context
&(*chat).context.sql, .sql
"SELECT c.addr FROM chats_contacts cc \ .query_row_col(
LEFT JOIN contacts c ON c.id=cc.contact_id \ (*chat).context,
WHERE cc.chat_id=?;", "SELECT c.addr FROM chats_contacts cc \
params![(*chat).id as i32], LEFT JOIN contacts c ON c.id=cc.contact_id \
0, WHERE cc.chat_id=?;",
) params![(*chat).id as i32],
.unwrap_or_else(|| "Err".into()); 0,
)
.unwrap_or_else(|| "Err".into());
ret = dc_strdup(to_cstring(ret_raw).as_ptr()); ret = dc_strdup(to_cstring(ret_raw).as_ptr());
} else if (*chat).type_0 == 120 || (*chat).type_0 == 130 { } else if (*chat).type_0 == 120 || (*chat).type_0 == 130 {
if (*chat).id == 1 { if (*chat).id == 1 {
@@ -2066,14 +2071,15 @@ pub unsafe fn dc_chat_get_subtitle(chat: *const Chat) -> *mut libc::c_char {
} }
pub fn dc_get_chat_contact_cnt(context: &Context, chat_id: u32) -> libc::c_int { pub fn dc_get_chat_contact_cnt(context: &Context, chat_id: u32) -> libc::c_int {
sql::query_row( context
context, .sql
&context.sql, .query_row_col(
"SELECT COUNT(*) FROM chats_contacts WHERE chat_id=?;", context,
params![chat_id as i32], "SELECT COUNT(*) FROM chats_contacts WHERE chat_id=?;",
0, params![chat_id as i32],
) 0,
.unwrap_or_default() )
.unwrap_or_default()
} }
pub unsafe fn dc_chat_get_profile_image(chat: *const Chat) -> *mut libc::c_char { pub unsafe fn dc_chat_get_profile_image(chat: *const Chat) -> *mut libc::c_char {
@@ -2164,14 +2170,15 @@ pub unsafe fn dc_chat_is_sending_locations(chat: *const Chat) -> libc::c_int {
pub fn dc_get_chat_cnt(context: &Context) -> usize { pub fn dc_get_chat_cnt(context: &Context) -> usize {
if context.sql.is_open() { if context.sql.is_open() {
/* no database, no chats - this is no error (needed eg. for information) */ /* no database, no chats - this is no error (needed eg. for information) */
sql::query_row::<_, isize>( context
context, .sql
&context.sql, .query_row_col::<_, isize>(
"SELECT COUNT(*) FROM chats WHERE id>9 AND blocked=0;", context,
params![], "SELECT COUNT(*) FROM chats WHERE id>9 AND blocked=0;",
0, params![],
) 0,
.unwrap_or_default() as usize )
.unwrap_or_default() as usize
} else { } else {
0 0
} }

43
src/dc_chatlist.rs
View File

@@ -6,7 +6,6 @@ use crate::dc_lot::*;
use crate::dc_msg::*; use crate::dc_msg::*;
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::*;
@@ -256,30 +255,32 @@ unsafe fn dc_chatlist_load_from_db(
// Context functions to work with chatlist // Context functions to work with chatlist
pub fn dc_get_archived_cnt(context: &Context) -> libc::c_int { pub fn dc_get_archived_cnt(context: &Context) -> libc::c_int {
sql::query_row( context
context, .sql
&context.sql, .query_row_col(
"SELECT COUNT(*) FROM chats WHERE blocked=0 AND archived=1;", context,
params![], "SELECT COUNT(*) FROM chats WHERE blocked=0 AND archived=1;",
0, params![],
) 0,
.unwrap_or_default() )
.unwrap_or_default()
} }
fn get_last_deaddrop_fresh_msg(context: &Context) -> u32 { fn get_last_deaddrop_fresh_msg(context: &Context) -> u32 {
// we have an index over the state-column, this should be sufficient as there are typically only few fresh messages // we have an index over the state-column, this should be sufficient as there are typically only few fresh messages
sql::query_row( context
context, .sql
&context.sql, .query_row_col(
"SELECT m.id FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id \ context,
WHERE m.state=10 \ "SELECT m.id FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id \
AND m.hidden=0 \ WHERE m.state=10 \
AND c.blocked=2 \ AND m.hidden=0 \
ORDER BY m.timestamp DESC, m.id DESC;", AND c.blocked=2 \
params![], ORDER BY m.timestamp DESC, m.id DESC;",
0, params![],
) 0,
.unwrap_or_default() )
.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 {

61
src/dc_configure.rs
View File

@@ -9,7 +9,6 @@ use crate::dc_saxparser::*;
use crate::dc_tools::*; use crate::dc_tools::*;
use crate::imap::*; use crate::imap::*;
use crate::oauth2::*; use crate::oauth2::*;
use crate::sql;
use crate::types::*; use crate::types::*;
use crate::x::*; use crate::x::*;
@@ -75,7 +74,7 @@ pub unsafe fn dc_has_ongoing(context: &Context) -> libc::c_int {
} }
} }
pub fn dc_is_configured(context: &Context) -> libc::c_int { pub fn dc_is_configured(context: &Context) -> libc::c_int {
if sql::get_config_int(context, &context.sql, "configured", 0) > 0 { if context.sql.get_config_int(context, "configured", 0) > 0 {
1 1
} else { } else {
0 0
@@ -168,12 +167,9 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context, _job: *mut dc_j
.and_then(|e| e.parse().ok()) .and_then(|e| e.parse().ok())
{ {
param.addr = oauth2_addr; param.addr = oauth2_addr;
sql::set_config( context
context, .sql
&context.sql, .set_config(context, "addr", Some(param.addr.as_str()));
"addr",
Some(param.addr.as_str()),
);
} }
if s.shall_stop_ongoing { if s.shall_stop_ongoing {
current_block = 2927484062889439186; current_block = 2927484062889439186;
@@ -900,25 +896,21 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context, _job: *mut dc_j
as uintptr_t, as uintptr_t,
0 as uintptr_t, 0 as uintptr_t,
); );
flags flags = if 0
= != context
if 0 .sql
!= .get_config_int(
sql::get_config_int( context,
context, &context.sql, "mvbox_watch",
"mvbox_watch", 1,
1 )
) || 0 != context
|| .sql
0 .get_config_int(
!= context,
sql::get_config_int( "mvbox_move",
context, 1,
&context.sql, ) {
"mvbox_move",
1
)
{
0x1 0x1
} else { } else {
0 0
@@ -959,12 +951,13 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context, _job: *mut dc_j
&context.sql, &context.sql,
"configured_", "configured_",
); );
sql::set_config_int( context
context, .sql
&context.sql, .set_config_int(
"configured", context,
1, "configured",
); 1,
);
if !s.shall_stop_ongoing if !s.shall_stop_ongoing
{ {
context.call_cb( context.call_cb(
@@ -1489,7 +1482,7 @@ pub fn dc_connect_to_configured_imap(context: &Context, imap: &Imap) -> libc::c_
if imap.is_connected() { if imap.is_connected() {
ret_connected = 1 ret_connected = 1
} else if sql::get_config_int(context, &context.sql, "configured", 0) == 0 { } else if context.sql.get_config_int(context, "configured", 0) == 0 {
warn!(context, 0, "Not configured, cannot connect.",); warn!(context, 0, "Not configured, cannot connect.",);
} else { } else {
let param = dc_loginparam_read(context, &context.sql, "configured_"); let param = dc_loginparam_read(context, &context.sql, "configured_");

100
src/dc_contact.rs
View File

@@ -70,15 +70,16 @@ pub unsafe fn dc_lookup_contact_id_by_addr(
let addr_normalized_c = dc_addr_normalize(addr); let addr_normalized_c = dc_addr_normalize(addr);
let addr_normalized = as_str(addr_normalized_c); let addr_normalized = as_str(addr_normalized_c);
let addr_self = let addr_self = context
sql::get_config(context, &context.sql, "configured_addr", None).unwrap_or_default(); .sql
.get_config(context, "configured_addr", None)
.unwrap_or_default();
let contact_id = if addr_normalized == addr_self { let contact_id = if addr_normalized == addr_self {
1 1
} else { } else {
sql::query_row( context.sql.query_row_col(
context, context,
&context.sql,
"SELECT id FROM contacts WHERE addr=?1 COLLATE NOCASE AND id>?2 AND origin>=?3 AND blocked=0;", "SELECT id FROM contacts WHERE addr=?1 COLLATE NOCASE AND id>?2 AND origin>=?3 AND blocked=0;",
params![addr_normalized, 9, 0x100], params![addr_normalized, 9, 0x100],
0 0
@@ -274,7 +275,10 @@ pub unsafe fn dc_contact_load_from_db(
(*contact).name = dc_stock_str((*contact).context, 2); (*contact).name = dc_stock_str((*contact).context, 2);
(*contact).addr = dc_strdup( (*contact).addr = dc_strdup(
to_cstring( to_cstring(
sql::get_config((*contact).context, sql, "configured_addr", Some("")) (*contact)
.context
.sql
.get_config((*contact).context, "configured_addr", Some(""))
.unwrap_or_default(), .unwrap_or_default(),
) )
.as_ptr(), .as_ptr(),
@@ -331,8 +335,10 @@ pub fn dc_add_or_lookup_contact(
let addr_c = unsafe { dc_addr_normalize(addr__) }; let addr_c = unsafe { dc_addr_normalize(addr__) };
let addr = as_str(addr_c); let addr = as_str(addr_c);
let addr_self = let addr_self = context
sql::get_config(context, &context.sql, "configured_addr", Some("")).unwrap_or_default(); .sql
.get_config(context, "configured_addr", Some(""))
.unwrap_or_default();
if addr == addr_self { if addr == addr_self {
return 1; return 1;
@@ -519,8 +525,10 @@ pub fn dc_get_contacts(
listflags: u32, listflags: u32,
query: *const libc::c_char, query: *const libc::c_char,
) -> *mut dc_array_t { ) -> *mut dc_array_t {
let self_addr = let self_addr = context
sql::get_config(context, &context.sql, "configured_addr", Some("")).unwrap_or_default(); .sql
.get_config(context, "configured_addr", Some(""))
.unwrap_or_default();
let mut add_self = false; let mut add_self = false;
let ret = unsafe { dc_array_new(100) }; let ret = unsafe { dc_array_new(100) };
@@ -558,8 +566,10 @@ pub fn dc_get_contacts(
) )
.unwrap(); // TODO: Better error handling .unwrap(); // TODO: Better error handling
let self_name = let self_name = context
sql::get_config(context, &context.sql, "displayname", Some("")).unwrap_or_default(); .sql
.get_config(context, "displayname", Some(""))
.unwrap_or_default();
let self_name2 = unsafe { dc_stock_str(context, 2) }; let self_name2 = unsafe { dc_stock_str(context, 2) };
@@ -595,14 +605,15 @@ pub fn dc_get_contacts(
} }
pub fn dc_get_blocked_cnt(context: &Context) -> libc::c_int { pub fn dc_get_blocked_cnt(context: &Context) -> libc::c_int {
sql::query_row( context
context, .sql
&context.sql, .query_row_col(
"SELECT COUNT(*) FROM contacts WHERE id>? AND blocked!=0", context,
params![9], "SELECT COUNT(*) FROM contacts WHERE id>? AND blocked!=0",
0, params![9],
) 0,
.unwrap_or_default() )
.unwrap_or_default()
} }
pub fn dc_get_blocked_contacts(context: &Context) -> *mut dc_array_t { pub fn dc_get_blocked_contacts(context: &Context) -> *mut dc_array_t {
@@ -757,24 +768,26 @@ pub fn dc_delete_contact(context: &Context, contact_id: u32) -> bool {
return false; return false;
} }
let count_contacts: i32 = sql::query_row( let count_contacts: i32 = context
context, .sql
&context.sql, .query_row_col(
"SELECT COUNT(*) FROM chats_contacts WHERE contact_id=?;",
params![contact_id as i32],
0,
)
.unwrap_or_default();
let count_msgs: i32 = if count_contacts > 0 {
sql::query_row(
context, context,
&context.sql, "SELECT COUNT(*) FROM chats_contacts WHERE contact_id=?;",
"SELECT COUNT(*) FROM msgs WHERE from_id=? OR to_id=?;", params![contact_id as i32],
params![contact_id as i32, contact_id as i32],
0, 0,
) )
.unwrap_or_default() .unwrap_or_default();
let count_msgs: i32 = if count_contacts > 0 {
context
.sql
.query_row_col(
context,
"SELECT COUNT(*) FROM msgs WHERE from_id=? OR to_id=?;",
params![contact_id as i32, contact_id as i32],
0,
)
.unwrap_or_default()
} else { } else {
0 0
}; };
@@ -974,7 +987,7 @@ pub fn dc_addr_equals_self(context: &Context, addr: *const libc::c_char) -> libc
if !addr.is_null() { if !addr.is_null() {
let normalized_addr = unsafe { dc_addr_normalize(addr) }; let normalized_addr = unsafe { dc_addr_normalize(addr) };
if let Some(self_addr) = sql::get_config(context, &context.sql, "configured_addr", None) { if let Some(self_addr) = context.sql.get_config(context, "configured_addr", None) {
ret = (as_str(normalized_addr) == self_addr) as libc::c_int; ret = (as_str(normalized_addr) == self_addr) as libc::c_int;
} }
unsafe { free(normalized_addr as *mut libc::c_void) }; unsafe { free(normalized_addr as *mut libc::c_void) };
@@ -1014,14 +1027,15 @@ pub fn dc_get_real_contact_cnt(context: &Context) -> usize {
return 0; return 0;
} }
sql::query_row::<_, isize>( context
context, .sql
&context.sql, .query_row_col::<_, isize>(
"SELECT COUNT(*) FROM contacts WHERE id>?;", context,
params![9], "SELECT COUNT(*) FROM contacts WHERE id>?;",
0, params![9],
) 0,
.unwrap_or_default() as usize )
.unwrap_or_default() as usize
} }
pub unsafe fn dc_get_contact_origin( pub unsafe fn dc_get_contact_origin(

9
src/dc_e2ee.rs
View File

@@ -24,7 +24,6 @@ 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::*;
@@ -81,13 +80,13 @@ 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 != sql::get_config_int(context, &context.sql, "e2ee_enabled", 1) { let prefer_encrypt = if 0 != context.sql.get_config_int(context, "e2ee_enabled", 1) {
EncryptPreference::Mutual EncryptPreference::Mutual
} else { } else {
EncryptPreference::NoPreference EncryptPreference::NoPreference
}; };
let addr = sql::get_config(context, &context.sql, "configured_addr", None); let addr = context.sql.get_config(context, "configured_addr", None);
if let Some(addr) = addr { if let Some(addr) = addr {
if let Some(public_key) = if let Some(public_key) =
@@ -597,7 +596,7 @@ pub unsafe fn dc_e2ee_decrypt(
} }
} }
/* load private key for decryption */ /* load private key for decryption */
let self_addr = sql::get_config(context, &context.sql, "configured_addr", None); let self_addr = context.sql.get_config(context, "configured_addr", None);
if let Some(self_addr) = self_addr { if let Some(self_addr) = self_addr {
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 {
@@ -1066,7 +1065,7 @@ 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 = sql::get_config(context, &context.sql, "configured_addr", None); let self_addr = context.sql.get_config(context, "configured_addr", None);
if self_addr.is_none() { if self_addr.is_none() {
warn!( warn!(
context, context,

36
src/dc_imex.rs
View File

@@ -69,8 +69,7 @@ pub unsafe fn dc_imex_has_backup(
if name.starts_with("delta-chat") && name.ends_with(".bak") { if name.starts_with("delta-chat") && name.ends_with(".bak") {
let sql = Sql::new(); let sql = Sql::new();
if sql.open(context, &path, 0x1) { if sql.open(context, &path, 0x1) {
let curr_backup_time = let curr_backup_time = sql.get_config_int(context, "backup_time", 0) as u64;
sql::get_config_int(context, &sql, "backup_time", 0) as u64;
if curr_backup_time > newest_backup_time { if curr_backup_time > newest_backup_time {
newest_backup_path = Some(path); newest_backup_path = Some(path);
newest_backup_time = curr_backup_time; newest_backup_time = curr_backup_time;
@@ -223,10 +222,12 @@ pub unsafe extern "C" fn dc_render_setup_file(
passphrase_begin[2usize] = 0i32 as libc::c_char; passphrase_begin[2usize] = 0i32 as libc::c_char;
/* create the payload */ /* create the payload */
if !(0 == dc_ensure_secret_key_exists(context)) { if !(0 == dc_ensure_secret_key_exists(context)) {
let self_addr = let self_addr = context
sql::get_config(context, &context.sql, "configured_addr", None).unwrap_or_default(); .sql
.get_config(context, "configured_addr", None)
.unwrap_or_default();
let curr_private_key = Key::from_self_private(context, self_addr, &context.sql); let curr_private_key = Key::from_self_private(context, self_addr, &context.sql);
let e2ee_enabled = sql::get_config_int(context, &context.sql, "e2ee_enabled", 1); let e2ee_enabled = context.sql.get_config_int(context, "e2ee_enabled", 1);
let headers = if 0 != e2ee_enabled { let headers = if 0 != e2ee_enabled {
Some(("Autocrypt-Prefer-Encrypt", "mutual")) Some(("Autocrypt-Prefer-Encrypt", "mutual"))
@@ -409,7 +410,7 @@ fn set_self_key(
error!(context, 0, "File does not contain a private key.",); error!(context, 0, "File does not contain a private key.",);
} }
let self_addr = sql::get_config(context, &context.sql, "configured_addr", None); let self_addr = context.sql.get_config(context, "configured_addr", None);
if self_addr.is_none() { if self_addr.is_none() {
error!(context, 0, "Missing self addr"); error!(context, 0, "Missing self addr");
@@ -430,8 +431,8 @@ fn set_self_key(
match preferencrypt.map(|s| s.as_str()) { match preferencrypt.map(|s| s.as_str()) {
Some("") => 0, Some("") => 0,
Some("nopreference") => sql::set_config_int(context, &context.sql, "e2ee_enabled", 0), Some("nopreference") => context.sql.set_config_int(context, "e2ee_enabled", 0),
Some("mutual") => sql::set_config_int(context, &context.sql, "e2ee_enabled", 1), Some("mutual") => context.sql.set_config_int(context, "e2ee_enabled", 1),
_ => 1, _ => 1,
} }
} }
@@ -781,14 +782,10 @@ unsafe fn import_backup(context: &Context, backup_to_import: *const libc::c_char
return 0; return 0;
} }
let total_files_cnt = sql::query_row::<_, isize>( let total_files_cnt = context
context, .sql
&context.sql, .query_row_col::<_, isize>(context, "SELECT COUNT(*) FROM backup_blobs;", params![], 0)
"SELECT COUNT(*) FROM backup_blobs;", .unwrap_or_default() as usize;
params![],
0,
)
.unwrap_or_default() as usize;
info!( info!(
context, context,
0, "***IMPORT-in-progress: total_files_cnt={:?}", total_files_cnt, 0, "***IMPORT-in-progress: total_files_cnt={:?}", total_files_cnt,
@@ -1040,12 +1037,7 @@ unsafe fn export_backup(context: &Context, dir: *const libc::c_char) -> libc::c_
match current_block { match current_block {
11487273724841241105 => {} 11487273724841241105 => {}
_ => { _ => {
if 0 != sql::set_config_int( if 0 != sql.set_config_int(context, "backup_time", now as i32) {
context,
&sql,
"backup_time",
now as i32,
) {
context.call_cb( context.call_cb(
Event::IMEX_FILE_WRITTEN, Event::IMEX_FILE_WRITTEN,
dest_pathNfilename as uintptr_t, dest_pathNfilename as uintptr_t,

72
src/dc_job.rs
View File

@@ -355,14 +355,15 @@ 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);
let chat_id: i32 = sql::query_row( let chat_id: i32 = context
context, .sql
&context.sql, .query_row_col(
"SELECT chat_id FROM msgs WHERE id=?", context,
params![job.foreign_id as i32], "SELECT chat_id FROM msgs WHERE id=?",
0, params![job.foreign_id as i32],
) 0,
.unwrap_or_default(); )
.unwrap_or_default();
context.call_cb( context.call_cb(
Event::MSG_DELIVERED, Event::MSG_DELIVERED,
chat_id as uintptr_t, chat_id as uintptr_t,
@@ -414,11 +415,12 @@ 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 sql::get_config_int(context, &context.sql, "folders_configured", 0) < 3 { if context.sql.get_config_int(context, "folders_configured", 0) < 3 {
inbox.configure_folders(context, 0x1i32); inbox.configure_folders(context, 0x1i32);
} }
let dest_folder = let dest_folder = context
sql::get_config(context, &context.sql, "configured_mvbox_folder", None); .sql
.get_config(context, "configured_mvbox_folder", None);
if let Some(dest_folder) = dest_folder { if let Some(dest_folder) = dest_folder {
let server_folder = as_str((*msg).server_folder); let server_folder = as_str((*msg).server_folder);
@@ -510,11 +512,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 sql::get_config_int(context, &context.sql, "folders_configured", 0) < 3 { if context.sql.get_config_int(context, "folders_configured", 0) < 3 {
inbox.configure_folders(context, 0x1i32); inbox.configure_folders(context, 0x1i32);
} }
let dest_folder = let dest_folder = context
sql::get_config(context, &context.sql, "configured_mvbox_folder", None); .sql
.get_config(context, "configured_mvbox_folder", None);
if let Some(dest_folder) = dest_folder { if let Some(dest_folder) = 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
@@ -559,12 +562,7 @@ 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 != sql::get_config_int( && 0 != context.sql.get_config_int(context, "mdns_enabled", 1)
context,
&context.sql,
"mdns_enabled",
1,
)
{ {
let folder = let folder =
CStr::from_ptr((*msg).server_folder).to_str().unwrap(); CStr::from_ptr((*msg).server_folder).to_str().unwrap();
@@ -615,12 +613,7 @@ 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 != sql::get_config_int( && 0 != context.sql.get_config_int(context, "mdns_enabled", 1)
context,
&context.sql,
"mdns_enabled",
1,
)
{ {
let folder = let folder =
CStr::from_ptr((*msg).server_folder).to_str().unwrap(); CStr::from_ptr((*msg).server_folder).to_str().unwrap();
@@ -909,7 +902,7 @@ pub unsafe fn dc_perform_imap_fetch(context: &Context) {
if 0 == connect_to_inbox(context, &inbox) { if 0 == connect_to_inbox(context, &inbox) {
return; return;
} }
if sql::get_config_int(context, &context.sql, "inbox_watch", 1) == 0 { if context.sql.get_config_int(context, "inbox_watch", 1) == 0 {
info!(context, 0, "INBOX-watch disabled.",); info!(context, 0, "INBOX-watch disabled.",);
return; return;
} }
@@ -945,7 +938,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 = sql::get_config_int(context, &context.sql, "mvbox_watch", 1); let use_network = context.sql.get_config_int(context, "mvbox_watch", 1);
dc_jobthread_fetch( dc_jobthread_fetch(
context, context,
&mut context.mvbox_thread.clone().write().unwrap(), &mut context.mvbox_thread.clone().write().unwrap(),
@@ -954,7 +947,7 @@ 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 = sql::get_config_int(context, &context.sql, "mvbox_watch", 1); let use_network = context.sql.get_config_int(context, "mvbox_watch", 1);
dc_jobthread_idle( dc_jobthread_idle(
context, context,
@@ -968,7 +961,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 = sql::get_config_int(context, &context.sql, "sentbox_watch", 1); let use_network = context.sql.get_config_int(context, "sentbox_watch", 1);
dc_jobthread_fetch( dc_jobthread_fetch(
context, context,
&mut context.sentbox_thread.clone().write().unwrap(), &mut context.sentbox_thread.clone().write().unwrap(),
@@ -977,7 +970,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 = sql::get_config_int(context, &context.sql, "sentbox_watch", 1); let use_network = context.sql.get_config_int(context, "sentbox_watch", 1);
dc_jobthread_idle( dc_jobthread_idle(
context, context,
&context.sentbox_thread.clone().read().unwrap(), &context.sentbox_thread.clone().read().unwrap(),
@@ -1049,14 +1042,15 @@ pub unsafe fn dc_perform_smtp_idle(context: &Context) {
} }
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 t: i64 = sql::query_row( let t: i64 = context
context, .sql
&context.sql, .query_row_col(
"SELECT MIN(desired_timestamp) FROM jobs WHERE thread=?;", context,
params![thread], "SELECT MIN(desired_timestamp) FROM jobs WHERE thread=?;",
0, params![thread],
) 0,
.unwrap_or_default(); )
.unwrap_or_default();
let mut wakeup_time = Duration::new(10 * 60, 0); let mut wakeup_time = Duration::new(10 * 60, 0);
let now = time(); let now = time();

7
src/dc_jobthread.rs
View File

@@ -3,7 +3,6 @@ use std::sync::{Arc, Condvar, Mutex};
use crate::context::Context; use crate::context::Context;
use crate::dc_configure::*; use crate::dc_configure::*;
use crate::imap::Imap; use crate::imap::Imap;
use crate::sql;
use crate::x::*; use crate::x::*;
#[repr(C)] #[repr(C)]
@@ -137,12 +136,14 @@ unsafe fn connect_to_imap(context: &Context, jobthread: &dc_jobthread_t) -> libc
let mut ret_connected = dc_connect_to_configured_imap(context, &jobthread.imap); let mut ret_connected = dc_connect_to_configured_imap(context, &jobthread.imap);
if !(0 == ret_connected) { if !(0 == ret_connected) {
if sql::get_config_int(context, &context.sql, "folders_configured", 0) < 3 { if context.sql.get_config_int(context, "folders_configured", 0) < 3 {
jobthread.imap.configure_folders(context, 0x1); jobthread.imap.configure_folders(context, 0x1);
} }
if let Some(mvbox_name) = if let Some(mvbox_name) =
sql::get_config(context, &context.sql, jobthread.folder_config_name, None) context
.sql
.get_config(context, jobthread.folder_config_name, None)
{ {
jobthread.imap.set_watch_folder(mvbox_name); jobthread.imap.set_watch_folder(mvbox_name);
} else { } else {

2
src/dc_location.rs
View File

@@ -261,7 +261,7 @@ pub fn dc_get_location_kml(
let mut location_count: libc::c_int = 0; let mut location_count: libc::c_int = 0;
let mut ret = String::new(); let mut ret = String::new();
let self_addr = sql::get_config(context, &context.sql, "configured_addr", Some("")); let self_addr = context.sql.get_config(context, "configured_addr", Some(""));
if self_addr.is_none() { if self_addr.is_none() {
return std::ptr::null_mut(); return std::ptr::null_mut();

43
src/dc_loginparam.rs
View File

@@ -1,7 +1,7 @@
use std::borrow::Cow; use std::borrow::Cow;
use crate::context::Context; use crate::context::Context;
use crate::sql::{self, Sql}; use crate::sql::Sql;
#[derive(Default, Debug)] #[derive(Default, Debug)]
pub struct dc_loginparam_t { pub struct dc_loginparam_t {
@@ -35,37 +35,38 @@ pub fn dc_loginparam_read(
let prefix = prefix.as_ref(); let prefix = prefix.as_ref();
let key = format!("{}addr", prefix); let key = format!("{}addr", prefix);
let addr = sql::get_config(context, sql, key, None) let addr = sql
.get_config(context, key, None)
.unwrap_or_default() .unwrap_or_default()
.trim() .trim()
.to_string(); .to_string();
let key = format!("{}mail_server", prefix); let key = format!("{}mail_server", prefix);
let mail_server = sql::get_config(context, sql, key, None).unwrap_or_default(); let mail_server = sql.get_config(context, key, None).unwrap_or_default();
let key = format!("{}mail_port", prefix); let key = format!("{}mail_port", prefix);
let mail_port = sql::get_config_int(context, sql, key, 0); let mail_port = sql.get_config_int(context, key, 0);
let key = format!("{}mail_user", prefix); let key = format!("{}mail_user", prefix);
let mail_user = sql::get_config(context, sql, key, None).unwrap_or_default(); let mail_user = sql.get_config(context, key, None).unwrap_or_default();
let key = format!("{}mail_pw", prefix); let key = format!("{}mail_pw", prefix);
let mail_pw = sql::get_config(context, sql, key, None).unwrap_or_default(); let mail_pw = sql.get_config(context, key, None).unwrap_or_default();
let key = format!("{}send_server", prefix); let key = format!("{}send_server", prefix);
let send_server = sql::get_config(context, sql, key, None).unwrap_or_default(); let send_server = sql.get_config(context, key, None).unwrap_or_default();
let key = format!("{}send_port", prefix); let key = format!("{}send_port", prefix);
let send_port = sql::get_config_int(context, sql, key, 0); let send_port = sql.get_config_int(context, key, 0);
let key = format!("{}send_user", prefix); let key = format!("{}send_user", prefix);
let send_user = sql::get_config(context, sql, key, None).unwrap_or_default(); let send_user = sql.get_config(context, key, None).unwrap_or_default();
let key = format!("{}send_pw", prefix); let key = format!("{}send_pw", prefix);
let send_pw = sql::get_config(context, sql, key, None).unwrap_or_default(); let send_pw = sql.get_config(context, key, None).unwrap_or_default();
let key = format!("{}server_flags", prefix); let key = format!("{}server_flags", prefix);
let server_flags = sql::get_config_int(context, sql, key, 0); let server_flags = sql.get_config_int(context, key, 0);
dc_loginparam_t { dc_loginparam_t {
addr: addr.to_string(), addr: addr.to_string(),
@@ -90,34 +91,34 @@ pub fn dc_loginparam_write(
let prefix = prefix.as_ref(); let prefix = prefix.as_ref();
let key = format!("{}addr", prefix); let key = format!("{}addr", prefix);
sql::set_config(context, sql, key, Some(&loginparam.addr)); sql.set_config(context, key, Some(&loginparam.addr));
let key = format!("{}mail_server", prefix); let key = format!("{}mail_server", prefix);
sql::set_config(context, sql, key, Some(&loginparam.mail_server)); sql.set_config(context, key, Some(&loginparam.mail_server));
let key = format!("{}mail_port", prefix); let key = format!("{}mail_port", prefix);
sql::set_config_int(context, sql, key, loginparam.mail_port); sql.set_config_int(context, key, loginparam.mail_port);
let key = format!("{}mail_user", prefix); let key = format!("{}mail_user", prefix);
sql::set_config(context, sql, key, Some(&loginparam.mail_user)); sql.set_config(context, key, Some(&loginparam.mail_user));
let key = format!("{}mail_pw", prefix); let key = format!("{}mail_pw", prefix);
sql::set_config(context, sql, key, Some(&loginparam.mail_pw)); sql.set_config(context, key, Some(&loginparam.mail_pw));
let key = format!("{}send_server", prefix); let key = format!("{}send_server", prefix);
sql::set_config(context, sql, key, Some(&loginparam.send_server)); sql.set_config(context, key, Some(&loginparam.send_server));
let key = format!("{}send_port", prefix); let key = format!("{}send_port", prefix);
sql::set_config_int(context, sql, key, loginparam.send_port); sql.set_config_int(context, key, loginparam.send_port);
let key = format!("{}send_user", prefix); let key = format!("{}send_user", prefix);
sql::set_config(context, sql, key, Some(&loginparam.send_user)); sql.set_config(context, key, Some(&loginparam.send_user));
let key = format!("{}send_pw", prefix); let key = format!("{}send_pw", prefix);
sql::set_config(context, sql, key, Some(&loginparam.send_pw)); sql.set_config(context, key, Some(&loginparam.send_pw));
let key = format!("{}server_flags", prefix); let key = format!("{}server_flags", prefix);
sql::set_config_int(context, sql, key, loginparam.server_flags); sql.set_config_int(context, key, loginparam.server_flags);
} }
fn unset_empty(s: &String) -> Cow<String> { fn unset_empty(s: &String) -> Cow<String> {

52
src/dc_mimefactory.rs
View File

@@ -19,7 +19,6 @@ use crate::dc_param::*;
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::*;
@@ -196,7 +195,9 @@ pub unsafe fn dc_mimefactory_load_msg(
0 as *const libc::c_char, 0 as *const libc::c_char,
); );
let email_to_remove = to_string(email_to_remove_c); let email_to_remove = to_string(email_to_remove_c);
let self_addr = sql::get_config(context, &context.sql, "configured_addr", Some("")) let self_addr = context
.sql
.get_config(context, "configured_addr", Some(""))
.unwrap_or_default(); .unwrap_or_default();
if !email_to_remove.is_empty() && email_to_remove != self_addr { if !email_to_remove.is_empty() && email_to_remove != self_addr {
@@ -218,7 +219,7 @@ pub unsafe fn dc_mimefactory_load_msg(
} }
if command != 6 if command != 6
&& command != 7 && command != 7
&& 0 != sql::get_config_int(context, &context.sql, "mdns_enabled", 1) && 0 != context.sql.get_config_int(context, "mdns_enabled", 1)
{ {
(*factory).req_mdn = 1 (*factory).req_mdn = 1
} }
@@ -261,39 +262,31 @@ pub unsafe fn dc_mimefactory_load_msg(
} }
unsafe fn load_from(mut factory: *mut dc_mimefactory_t) { unsafe fn load_from(mut factory: *mut dc_mimefactory_t) {
let context = (*factory).context;
(*factory).from_addr = strdup( (*factory).from_addr = strdup(
to_cstring( to_cstring(
sql::get_config( context
(*factory).context, .sql
&(*factory).context.sql, .get_config(context, "configured_addr", None)
"configured_addr", .unwrap_or_default(),
None,
)
.unwrap_or_default(),
) )
.as_ptr(), .as_ptr(),
); );
(*factory).from_displayname = strdup( (*factory).from_displayname = strdup(
to_cstring( to_cstring(
sql::get_config( context
(*factory).context, .sql
&(*factory).context.sql, .get_config(context, "displayname", None)
"displayname", .unwrap_or_default(),
None,
)
.unwrap_or_default(),
) )
.as_ptr(), .as_ptr(),
); );
(*factory).selfstatus = strdup( (*factory).selfstatus = strdup(
to_cstring( to_cstring(
sql::get_config( context
(*factory).context, .sql
&(*factory).context.sql, .get_config(context, "selfstatus", None)
"selfstatus", .unwrap_or_default(),
None,
)
.unwrap_or_default(),
) )
.as_ptr(), .as_ptr(),
); );
@@ -316,12 +309,11 @@ pub unsafe fn dc_mimefactory_load_mdn(
(*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 != sql::get_config_int( if 0 != (*factory)
(*factory).context, .context
&(*factory).context.sql, .sql
"mdns_enabled", .get_config_int((*factory).context, "mdns_enabled", 1)
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)

3
src/dc_move.rs
View File

@@ -2,10 +2,9 @@ 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::sql;
pub unsafe fn dc_do_heuristics_moves(context: &Context, folder: &str, msg_id: u32) { pub unsafe fn dc_do_heuristics_moves(context: &Context, folder: &str, msg_id: u32) {
if sql::get_config_int(context, &context.sql, "mvbox_move", 1) == 0 { if context.sql.get_config_int(context, "mvbox_move", 1) == 0 {
return; return;
} }

26
src/dc_msg.rs
View File

@@ -52,9 +52,8 @@ pub unsafe fn dc_get_msg_info(context: &Context, msg_id: u32) -> *mut libc::c_ch
dc_msg_load_from_db(msg, context, msg_id); dc_msg_load_from_db(msg, context, msg_id);
dc_contact_load_from_db(contact_from, &context.sql, (*msg).from_id); dc_contact_load_from_db(contact_from, &context.sql, (*msg).from_id);
let rawtxt: Option<String> = sql::query_row( let rawtxt: Option<String> = context.sql.query_row_col(
context, context,
&context.sql,
"SELECT txt_raw FROM msgs WHERE id=?;", "SELECT txt_raw FROM msgs WHERE id=?;",
params![msg_id as i32], params![msg_id as i32],
0, 0,
@@ -487,9 +486,8 @@ pub fn dc_msg_load_from_db<'a>(msg: *mut dc_msg_t<'a>, context: &'a Context, id:
} }
pub unsafe fn dc_get_mime_headers(context: &Context, msg_id: uint32_t) -> *mut libc::c_char { pub unsafe fn dc_get_mime_headers(context: &Context, msg_id: uint32_t) -> *mut libc::c_char {
let headers: Option<String> = sql::query_row( let headers: Option<String> = context.sql.query_row_col(
context, context,
&context.sql,
"SELECT mime_headers FROM msgs WHERE id=?;", "SELECT mime_headers FROM msgs WHERE id=?;",
params![msg_id as i32], params![msg_id as i32],
0, 0,
@@ -1132,9 +1130,8 @@ pub unsafe fn dc_msg_exists(context: &Context, msg_id: uint32_t) -> libc::c_int
return 0; return 0;
} }
let chat_id: Option<i32> = sql::query_row( let chat_id: Option<i32> = context.sql.query_row_col(
context, context,
&context.sql,
"SELECT chat_id FROM msgs WHERE id=?;", "SELECT chat_id FROM msgs WHERE id=?;",
params![msg_id as i32], params![msg_id as i32],
0, 0,
@@ -1255,14 +1252,15 @@ pub unsafe fn dc_mdn_from_ext(
read_by_all = 1; read_by_all = 1;
} else { } else {
/* send event about new state */ /* send event about new state */
let ist_cnt: i32 = sql::query_row( let ist_cnt: i32 = context
context, .sql
&context.sql, .query_row_col(
"SELECT COUNT(*) FROM msgs_mdns WHERE msg_id=?;", context,
params![*ret_msg_id as i32], "SELECT COUNT(*) FROM msgs_mdns WHERE msg_id=?;",
0, params![*ret_msg_id as i32],
) 0,
.unwrap_or_default(); )
.unwrap_or_default();
/* /*
Groupsize: Min. MDNs Groupsize: Min. MDNs

30
src/dc_receive_imf.rs
View File

@@ -217,7 +217,7 @@ pub unsafe fn dc_receive_imf(
let mut allow_creation: libc::c_int = 1; let mut allow_creation: libc::c_int = 1;
if msgrmsg == 0 { if msgrmsg == 0 {
let show_emails: libc::c_int = let show_emails: libc::c_int =
sql::get_config_int(context, &context.sql, "show_emails", 0); context.sql.get_config_int(context, "show_emails", 0);
if show_emails == 0 { if show_emails == 0 {
chat_id = 3 as uint32_t; chat_id = 3 as uint32_t;
allow_creation = 0 allow_creation = 0
@@ -404,7 +404,7 @@ pub unsafe fn dc_receive_imf(
// if the mime-headers should be saved, find out its size // if the mime-headers should be saved, find out its size
// (the mime-header ends with an empty line) // (the mime-header ends with an empty line)
let save_mime_headers = let save_mime_headers =
sql::get_config_int(context, &context.sql, "save_mime_headers", 0); context.sql.get_config_int(context, "save_mime_headers", 0);
field = dc_mimeparser_lookup_field(&mime_parser, "In-Reply-To"); field = dc_mimeparser_lookup_field(&mime_parser, "In-Reply-To");
if !field.is_null() if !field.is_null()
&& (*field).fld_type == MAILIMF_FIELD_IN_REPLY_TO as libc::c_int && (*field).fld_type == MAILIMF_FIELD_IN_REPLY_TO as libc::c_int
@@ -581,8 +581,7 @@ pub unsafe fn dc_receive_imf(
16282941964262048061 => {} 16282941964262048061 => {}
_ => { _ => {
if carray_count(mime_parser.reports) > 0 as libc::c_uint { if carray_count(mime_parser.reports) > 0 as libc::c_uint {
let mdns_enabled = let mdns_enabled = context.sql.get_config_int(context, "mdns_enabled", 1);
sql::get_config_int(context, &context.sql, "mdns_enabled", 1);
icnt = carray_count(mime_parser.reports) as size_t; icnt = carray_count(mime_parser.reports) as size_t;
i = 0 as size_t; i = 0 as size_t;
while i < icnt { while i < icnt {
@@ -740,12 +739,7 @@ pub unsafe fn dc_receive_imf(
); );
dc_param_set_int(param, 'z' as i32, server_uid as i32); dc_param_set_int(param, 'z' as i32, server_uid as i32);
if 0 != mime_parser.is_send_by_messenger if 0 != mime_parser.is_send_by_messenger
&& 0 != sql::get_config_int( && 0 != context.sql.get_config_int(context, "mvbox_move", 1)
context,
&context.sql,
"mvbox_move",
1,
)
{ {
dc_param_set_int(param, 'M' as i32, 1); dc_param_set_int(param, 'M' as i32, 1);
} }
@@ -860,9 +854,8 @@ unsafe fn calc_timestamps(
} }
*sort_timestamp = message_timestamp; *sort_timestamp = message_timestamp;
if 0 != is_fresh_msg { if 0 != is_fresh_msg {
let last_msg_time: Option<i64> = sql::query_row( let last_msg_time: Option<i64> = context.sql.query_row_col(
context, context,
&context.sql,
"SELECT MAX(timestamp) FROM msgs WHERE chat_id=? and from_id!=? AND timestamp>=?", "SELECT MAX(timestamp) FROM msgs WHERE chat_id=? and from_id!=? AND timestamp>=?",
params![chat_id as i32, from_id as i32, *sort_timestamp], params![chat_id as i32, from_id as i32, *sort_timestamp],
0, 0,
@@ -1107,7 +1100,9 @@ unsafe fn create_or_lookup_group(
} }
/* check if the group does not exist but should be created */ /* check if the group does not exist but should be created */
group_explicitly_left = dc_is_group_explicitly_left(context, grpid); group_explicitly_left = dc_is_group_explicitly_left(context, grpid);
let self_addr = sql::get_config(context, &context.sql, "configured_addr", Some("")) let self_addr = context
.sql
.get_config(context, "configured_addr", Some(""))
.unwrap_or_default(); .unwrap_or_default();
if chat_id == 0 as libc::c_uint if chat_id == 0 as libc::c_uint
&& 0 == dc_mimeparser_is_mailinglist_message(mime_parser) && 0 == dc_mimeparser_is_mailinglist_message(mime_parser)
@@ -1473,7 +1468,9 @@ unsafe fn create_adhoc_grp_id(context: &Context, member_ids: *mut dc_array_t) ->
- encode the first 64 bits of the sha-256 output as lowercase hex (results in 16 characters from the set [0-9a-f]) - encode the first 64 bits of the sha-256 output as lowercase hex (results in 16 characters from the set [0-9a-f])
*/ */
let member_ids_str = dc_array_get_string(member_ids, b",\x00" as *const u8 as *const _); let member_ids_str = dc_array_get_string(member_ids, b",\x00" as *const u8 as *const _);
let member_cs = sql::get_config(context, &context.sql, "configured_addr", Some("no-self")) let member_cs = context
.sql
.get_config(context, "configured_addr", Some("no-self"))
.unwrap() .unwrap()
.to_lowercase(); .to_lowercase();
@@ -1979,7 +1976,10 @@ unsafe fn add_or_lookup_contact_by_addr(
return; return;
} }
*check_self = 0; *check_self = 0;
let self_addr = sql::get_config(context, &context.sql, "configured_addr", Some("")).unwrap(); let self_addr = context
.sql
.get_config(context, "configured_addr", Some(""))
.unwrap();
if dc_addr_cmp(self_addr, as_str(addr_spec)) { if dc_addr_cmp(self_addr, as_str(addr_spec)) {
*check_self = 1; *check_self = 1;

27
src/dc_securejoin.rs
View File

@@ -20,7 +20,6 @@ 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::*;
@@ -52,7 +51,7 @@ 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);
} }
let self_addr = sql::get_config(context, &context.sql, "configured_addr", None); let self_addr = context.sql.get_config(context, "configured_addr", None);
let cleanup = |fingerprint, chat, group_name, group_name_urlencoded| { let cleanup = |fingerprint, chat, group_name, group_name_urlencoded| {
free(fingerprint as *mut libc::c_void); free(fingerprint as *mut libc::c_void);
@@ -75,7 +74,10 @@ pub unsafe fn dc_get_securejoin_qr(
} }
let self_addr = self_addr.unwrap(); let self_addr = self_addr.unwrap();
let self_name = sql::get_config(context, &context.sql, "displayname", Some("")).unwrap(); let self_name = context
.sql
.get_config(context, "displayname", Some(""))
.unwrap();
fingerprint = get_self_fingerprint(context); fingerprint = get_self_fingerprint(context);
if fingerprint.is_null() { if fingerprint.is_null() {
@@ -124,7 +126,7 @@ pub unsafe fn dc_get_securejoin_qr(
} }
fn get_self_fingerprint(context: &Context) -> *mut libc::c_char { 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(self_addr) = context.sql.get_config(context, "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();
} }
@@ -919,14 +921,15 @@ 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 {
let contact_id: i32 = sql::query_row( let contact_id: i32 = context
context, .sql
&context.sql, .query_row_col(
"SELECT id FROM contacts WHERE addr=?;", context,
params![&peerstate.addr], "SELECT id FROM contacts WHERE addr=?;",
0, params![&peerstate.addr],
) 0,
.unwrap_or_default(); )
.unwrap_or_default();
if contact_id > 0 { if contact_id > 0 {
dc_create_or_lookup_nchat_by_contact_id( dc_create_or_lookup_nchat_by_contact_id(
context, context,

3
src/dc_token.rs
View File

@@ -33,9 +33,8 @@ pub fn dc_token_lookup(
namespc: dc_tokennamespc_t, namespc: dc_tokennamespc_t,
foreign_id: u32, foreign_id: u32,
) -> *mut libc::c_char { ) -> *mut libc::c_char {
if let Some(token) = sql::query_row::<_, String>( if let Some(token) = context.sql.query_row_col::<_, String>(
context, context,
&context.sql,
"SELECT token FROM tokens WHERE namespc=? AND foreign_id=?;", "SELECT token FROM tokens WHERE namespc=? AND foreign_id=?;",
params![namespc as i32, foreign_id as i32], params![namespc as i32, foreign_id as i32],
0, 0,

15
src/imap.rs
View File

@@ -8,7 +8,6 @@ use crate::context::Context;
use crate::dc_loginparam::*; use crate::dc_loginparam::*;
use crate::dc_tools::as_str; use crate::dc_tools::as_str;
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;
@@ -1598,19 +1597,15 @@ impl Imap {
} }
} }
sql::set_config_int(context, &context.sql, "folders_configured", 3); context.sql.set_config_int(context, "folders_configured", 3);
if let Some(ref mvbox_folder) = mvbox_folder { if let Some(ref mvbox_folder) = mvbox_folder {
sql::set_config( context
context, .sql
&context.sql, .set_config(context, "configured_mvbox_folder", Some(mvbox_folder));
"configured_mvbox_folder",
Some(mvbox_folder),
);
} }
if let Some(ref sentbox_folder) = sentbox_folder { if let Some(ref sentbox_folder) = sentbox_folder {
sql::set_config( context.sql.set_config(
context, context,
&context.sql,
"configured_sentbox_folder", "configured_sentbox_folder",
Some(sentbox_folder.name()), Some(sentbox_folder.name()),
); );

6
src/key.rs
View File

@@ -149,9 +149,8 @@ impl Key {
) -> Option<Self> { ) -> Option<Self> {
let addr = self_addr.as_ref(); let addr = self_addr.as_ref();
sql::query_row( sql.query_row_col(
context, context,
sql,
"SELECT public_key FROM keypairs WHERE addr=? AND is_default=1;", "SELECT public_key FROM keypairs WHERE addr=? AND is_default=1;",
&[addr], &[addr],
0, 0,
@@ -164,9 +163,8 @@ impl Key {
self_addr: impl AsRef<str>, self_addr: impl AsRef<str>,
sql: &Sql, sql: &Sql,
) -> Option<Self> { ) -> Option<Self> {
sql::query_row( sql.query_row_col(
context, context,
sql,
"SELECT private_key FROM keypairs WHERE addr=? AND is_default=1;", "SELECT private_key FROM keypairs WHERE addr=? AND is_default=1;",
&[self_addr.as_ref()], &[self_addr.as_ref()],
0, 0,

5
src/keyring.rs
View File

@@ -3,7 +3,7 @@ use std::borrow::Cow;
use crate::constants::*; use crate::constants::*;
use crate::context::Context; use crate::context::Context;
use crate::key::*; use crate::key::*;
use crate::sql::{self, Sql}; use crate::sql::Sql;
#[derive(Default, Clone, Debug)] #[derive(Default, Clone, Debug)]
pub struct Keyring<'a> { pub struct Keyring<'a> {
@@ -33,9 +33,8 @@ impl<'a> Keyring<'a> {
self_addr: impl AsRef<str>, self_addr: impl AsRef<str>,
sql: &Sql, sql: &Sql,
) -> bool { ) -> bool {
sql::query_row( sql.query_row_col(
context, context,
sql,
"SELECT private_key FROM keypairs ORDER BY addr=? DESC, is_default DESC;", "SELECT private_key FROM keypairs ORDER BY addr=? DESC, is_default DESC;",
&[self_addr.as_ref()], &[self_addr.as_ref()],
0, 0,

64
src/oauth2.rs
View File

@@ -5,7 +5,6 @@ use serde::Deserialize;
use crate::context::Context; use crate::context::Context;
use crate::dc_tools::*; use crate::dc_tools::*;
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",
@@ -49,9 +48,8 @@ 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) {
sql::set_config( context.sql.set_config(
context, context,
&context.sql,
"oauth2_pending_redirect_uri", "oauth2_pending_redirect_uri",
Some(redirect_uri.as_ref()), Some(redirect_uri.as_ref()),
); );
@@ -78,17 +76,20 @@ 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 = sql::get_config(context, &context.sql, "oauth2_access_token", None); let access_token = context.sql.get_config(context, "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 = sql::get_config(context, &context.sql, "oauth2_refresh_token", None); let refresh_token = context
let refresh_token_for = .sql
sql::get_config(context, &context.sql, "oauth2_refresh_token_for", None) .get_config(context, "oauth2_refresh_token", None);
.unwrap_or_else(|| "unset".into()); let refresh_token_for = context
.sql
.get_config(context, "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 +98,9 @@ pub fn dc_get_oauth2_access_token(
0, "Generate OAuth2 refresh_token and access_token...", 0, "Generate OAuth2 refresh_token and access_token...",
); );
( (
sql::get_config(context, &context.sql, "oauth2_pending_redirect_uri", None) context
.sql
.get_config(context, "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 +111,9 @@ pub fn dc_get_oauth2_access_token(
0, "Regenerate OAuth2 access_token by refresh_token...", 0, "Regenerate OAuth2 access_token by refresh_token...",
); );
( (
sql::get_config(context, &context.sql, "oauth2_redirect_uri", None) context
.sql
.get_config(context, "oauth2_redirect_uri", None)
.unwrap_or_else(|| "unset".into()), .unwrap_or_else(|| "unset".into()),
oauth2.refresh_token, oauth2.refresh_token,
false, false,
@@ -152,38 +157,33 @@ 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 {
sql::set_config(context, &context.sql, "oauth2_refresh_token", Some(token)); context
sql::set_config( .sql
context, .set_config(context, "oauth2_refresh_token", Some(token));
&context.sql, context
"oauth2_refresh_token_for", .sql
Some(code.as_ref()), .set_config(context, "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 {
sql::set_config(context, &context.sql, "oauth2_access_token", Some(token)); context
.sql
.set_config(context, "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);
sql::set_config_int64( context
context, .sql
&context.sql, .set_config_int64(context, "oauth2_timestamp_expires", expires_in);
"oauth2_timestamp_expires",
expires_in,
);
if update_redirect_uri_on_success { if update_redirect_uri_on_success {
sql::set_config( context
context, .sql
&context.sql, .set_config(context, "oauth2_redirect_uri", Some(redirect_uri.as_ref()));
"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");
@@ -297,7 +297,9 @@ impl Oauth2 {
fn is_expired(context: &Context) -> bool { fn is_expired(context: &Context) -> bool {
let expire_timestamp = let expire_timestamp =
sql::get_config_int64(context, &context.sql, "oauth2_timestamp_expires", Some(0)); context
.sql
.get_config_int64(context, "oauth2_timestamp_expires", Some(0));
if expire_timestamp <= 0 { if expire_timestamp <= 0 {
return false; return false;

325
src/sql.rs
View File

@@ -146,6 +146,138 @@ impl Sql {
self.with_conn(|conn| Ok(table_exists(conn, name))) self.with_conn(|conn| Ok(table_exists(conn, name)))
.unwrap_or_default() .unwrap_or_default()
} }
pub fn query_row_col<P, T>(
&self,
context: &Context,
query: &str,
params: P,
column: usize,
) -> Option<T>
where
P: IntoIterator,
P::Item: rusqlite::ToSql,
T: rusqlite::types::FromSql,
{
match self.query_row(query, params, |row| row.get::<_, T>(column)) {
Ok(res) => Some(res),
Err(Error::Sql(rusqlite::Error::QueryReturnedNoRows)) => None,
Err(Error::Sql(rusqlite::Error::InvalidColumnType(
_,
_,
rusqlite::types::Type::Null,
))) => None,
Err(err) => {
error!(context, 0, "sql: Failed query_row: {}", err);
None
}
}
}
/// Set private configuration options.
pub fn set_config(
&self,
context: &Context,
key: impl AsRef<str>,
value: Option<&str>,
) -> libc::c_int {
if !self.is_open() {
error!(context, 0, "set_config(): Database not ready.");
return 0;
}
let key = key.as_ref();
let good;
if let Some(ref value) = value {
let exists = self
.exists("SELECT value FROM config WHERE keyname=?;", params![key])
.unwrap_or_default();
if exists {
good = execute(
context,
self,
"UPDATE config SET value=? WHERE keyname=?;",
params![value, key],
);
} else {
good = execute(
context,
self,
"INSERT INTO config (keyname, value) VALUES (?, ?);",
params![key, value],
);
}
} else {
good = execute(
context,
self,
"DELETE FROM config WHERE keyname=?;",
params![key],
);
}
if !good {
error!(context, 0, "set_config(): Cannot change value.",);
return 0;
}
1
}
/// Get configuration options from the database.
pub fn get_config(
&self,
context: &Context,
key: impl AsRef<str>,
def: Option<&str>,
) -> Option<String> {
if !self.is_open() || key.as_ref().is_empty() {
return None;
}
self.query_row_col(
context,
"SELECT value FROM config WHERE keyname=?;",
params![key.as_ref()],
0,
)
.or_else(|| def.map(|s| s.to_string()))
}
pub fn set_config_int(
&self,
context: &Context,
key: impl AsRef<str>,
value: i32,
) -> libc::c_int {
self.set_config(context, key, Some(&format!("{}", value)))
}
pub fn get_config_int(&self, context: &Context, key: impl AsRef<str>, def: i32) -> i32 {
self.get_config(context, key, None)
.and_then(|s| s.parse().ok())
.unwrap_or_else(|| def)
}
pub fn set_config_int64(
&self,
context: &Context,
key: impl AsRef<str>,
value: i64,
) -> libc::c_int {
self.set_config(context, key, Some(&format!("{}", value)))
}
pub fn get_config_int64(
&self,
context: &Context,
key: impl AsRef<str>,
def: Option<i64>,
) -> i64 {
let ret = self.get_config(context, key, None);
ret.map(|r| r.parse().unwrap_or_default())
.unwrap_or_else(|| def.unwrap_or_default())
}
} }
fn table_exists(conn: &Connection, name: impl AsRef<str>) -> bool { fn table_exists(conn: &Connection, name: impl AsRef<str>) -> bool {
@@ -328,11 +460,11 @@ fn open(
// cannot create the tables - maybe we cannot write? // cannot create the tables - maybe we cannot write?
return Err(Error::SqlFailedToOpen); return Err(Error::SqlFailedToOpen);
} else { } else {
set_config_int(context, sql, "dbversion", 0); sql.set_config_int(context, "dbversion", 0);
} }
} else { } else {
exists_before_update = 1; exists_before_update = 1;
dbversion_before_update = get_config_int(context, sql, "dbversion", 0); dbversion_before_update = sql.get_config_int(context, "dbversion", 0);
} }
// (1) update low-level database structure. // (1) update low-level database structure.
@@ -353,7 +485,7 @@ fn open(
params![], params![],
)?; )?;
dbversion = 1; dbversion = 1;
set_config_int(context, sql, "dbversion", 1); sql.set_config_int(context, "dbversion", 1);
} }
if dbversion < 2 { if dbversion < 2 {
sql.execute( sql.execute(
@@ -361,7 +493,7 @@ fn open(
params![], params![],
)?; )?;
dbversion = 2; dbversion = 2;
set_config_int(context, sql, "dbversion", 2); sql.set_config_int(context, "dbversion", 2);
} }
if dbversion < 7 { if dbversion < 7 {
sql.execute( sql.execute(
@@ -375,7 +507,7 @@ fn open(
params![], params![],
)?; )?;
dbversion = 7; dbversion = 7;
set_config_int(context, sql, "dbversion", 7); sql.set_config_int(context, "dbversion", 7);
} }
if dbversion < 10 { if dbversion < 10 {
sql.execute( sql.execute(
@@ -393,7 +525,7 @@ fn open(
params![], params![],
)?; )?;
dbversion = 10; dbversion = 10;
set_config_int(context, sql, "dbversion", 10); sql.set_config_int(context, "dbversion", 10);
} }
if dbversion < 12 { if dbversion < 12 {
sql.execute( sql.execute(
@@ -405,7 +537,7 @@ fn open(
params![], params![],
)?; )?;
dbversion = 12; dbversion = 12;
set_config_int(context, sql, "dbversion", 12); sql.set_config_int(context, "dbversion", 12);
} }
if dbversion < 17 { if dbversion < 17 {
sql.execute( sql.execute(
@@ -419,7 +551,7 @@ fn open(
)?; )?;
sql.execute("CREATE INDEX msgs_index5 ON msgs (starred);", params![])?; sql.execute("CREATE INDEX msgs_index5 ON msgs (starred);", params![])?;
dbversion = 17; dbversion = 17;
set_config_int(context, sql, "dbversion", 17); sql.set_config_int(context, "dbversion", 17);
} }
if dbversion < 18 { if dbversion < 18 {
sql.execute( sql.execute(
@@ -428,7 +560,7 @@ fn open(
)?; )?;
sql.execute("ALTER TABLE acpeerstates ADD COLUMN gossip_key;", params![])?; sql.execute("ALTER TABLE acpeerstates ADD COLUMN gossip_key;", params![])?;
dbversion = 18; dbversion = 18;
set_config_int(context, sql, "dbversion", 18); sql.set_config_int(context, "dbversion", 18);
} }
if dbversion < 27 { if dbversion < 27 {
sql.execute("DELETE FROM msgs WHERE chat_id=1 OR chat_id=2;", params![])?; sql.execute("DELETE FROM msgs WHERE chat_id=1 OR chat_id=2;", params![])?;
@@ -445,7 +577,7 @@ fn open(
params![], params![],
)?; )?;
dbversion = 27; dbversion = 27;
set_config_int(context, sql, "dbversion", 27); sql.set_config_int(context, "dbversion", 27);
} }
if dbversion < 34 { if dbversion < 34 {
sql.execute( sql.execute(
@@ -474,7 +606,7 @@ fn open(
)?; )?;
recalc_fingerprints = 1; recalc_fingerprints = 1;
dbversion = 34; dbversion = 34;
set_config_int(context, sql, "dbversion", 34); sql.set_config_int(context, "dbversion", 34);
} }
if dbversion < 39 { if dbversion < 39 {
sql.execute( sql.execute(
@@ -504,7 +636,7 @@ fn open(
)?; )?;
} }
dbversion = 39; dbversion = 39;
set_config_int(context, sql, "dbversion", 39); sql.set_config_int(context, "dbversion", 39);
} }
if dbversion < 40 { if dbversion < 40 {
sql.execute( sql.execute(
@@ -512,22 +644,22 @@ fn open(
params![], params![],
)?; )?;
dbversion = 40; dbversion = 40;
set_config_int(context, sql, "dbversion", 40); sql.set_config_int(context, "dbversion", 40);
} }
if dbversion < 41 { if dbversion < 41 {
update_file_paths = 1; update_file_paths = 1;
dbversion = 41; dbversion = 41;
set_config_int(context, sql, "dbversion", 41); sql.set_config_int(context, "dbversion", 41);
} }
if dbversion < 42 { if dbversion < 42 {
sql.execute("UPDATE msgs SET txt='' WHERE type!=10", params![])?; sql.execute("UPDATE msgs SET txt='' WHERE type!=10", params![])?;
dbversion = 42; dbversion = 42;
set_config_int(context, sql, "dbversion", 42); sql.set_config_int(context, "dbversion", 42);
} }
if dbversion < 44 { if dbversion < 44 {
sql.execute("ALTER TABLE msgs ADD COLUMN mime_headers TEXT;", params![])?; sql.execute("ALTER TABLE msgs ADD COLUMN mime_headers TEXT;", params![])?;
dbversion = 44; dbversion = 44;
set_config_int(context, sql, "dbversion", 44); sql.set_config_int(context, "dbversion", 44);
} }
if dbversion < 46 { if dbversion < 46 {
sql.execute( sql.execute(
@@ -539,7 +671,7 @@ fn open(
params![], params![],
)?; )?;
dbversion = 46; dbversion = 46;
set_config_int(context, sql, "dbversion", 46); sql.set_config_int(context, "dbversion", 46);
} }
if dbversion < 47 { if dbversion < 47 {
info!(context, 0, "[migration] v47"); info!(context, 0, "[migration] v47");
@@ -548,7 +680,7 @@ fn open(
params![], params![],
)?; )?;
dbversion = 47; dbversion = 47;
set_config_int(context, sql, "dbversion", 47); sql.set_config_int(context, "dbversion", 47);
} }
if dbversion < 48 { if dbversion < 48 {
info!(context, 0, "[migration] v48"); info!(context, 0, "[migration] v48");
@@ -562,7 +694,7 @@ fn open(
assert_eq!(DC_MOVE_STATE_MOVING as libc::c_int, 3); assert_eq!(DC_MOVE_STATE_MOVING as libc::c_int, 3);
dbversion = 48; dbversion = 48;
set_config_int(context, sql, "dbversion", 48); sql.set_config_int(context, "dbversion", 48);
} }
if dbversion < 49 { if dbversion < 49 {
info!(context, 0, "[migration] v49"); info!(context, 0, "[migration] v49");
@@ -571,15 +703,15 @@ fn open(
params![], params![],
)?; )?;
dbversion = 49; dbversion = 49;
set_config_int(context, sql, "dbversion", 49); sql.set_config_int(context, "dbversion", 49);
} }
if dbversion < 50 { if dbversion < 50 {
info!(context, 0, "[migration] v50"); info!(context, 0, "[migration] v50");
if 0 != exists_before_update { if 0 != exists_before_update {
set_config_int(context, sql, "show_emails", 2); sql.set_config_int(context, "show_emails", 2);
} }
dbversion = 50; dbversion = 50;
set_config_int(context, sql, "dbversion", 50); sql.set_config_int(context, "dbversion", 50);
} }
if dbversion < 53 { if dbversion < 53 {
info!(context, 0, "[migration] v53"); info!(context, 0, "[migration] v53");
@@ -612,7 +744,7 @@ fn open(
params![], params![],
)?; )?;
dbversion = 53; dbversion = 53;
set_config_int(context, sql, "dbversion", 53); sql.set_config_int(context, "dbversion", 53);
} }
if dbversion < 54 { if dbversion < 54 {
info!(context, 0, "[migration] v54"); info!(context, 0, "[migration] v54");
@@ -622,7 +754,7 @@ fn open(
)?; )?;
sql.execute("CREATE INDEX msgs_index6 ON msgs (location_id);", params![])?; sql.execute("CREATE INDEX msgs_index6 ON msgs (location_id);", params![])?;
dbversion = 54; dbversion = 54;
set_config_int(context, sql, "dbversion", 54); sql.set_config_int(context, "dbversion", 54);
} }
if dbversion < 55 { if dbversion < 55 {
sql.execute( sql.execute(
@@ -630,7 +762,7 @@ fn open(
params![], params![],
)?; )?;
set_config_int(context, sql, "dbversion", 55); sql.set_config_int(context, "dbversion", 55);
} }
if 0 != recalc_fingerprints { if 0 != recalc_fingerprints {
@@ -657,13 +789,9 @@ fn open(
info!(context, 0, "[open] update file paths"); info!(context, 0, "[open] update file paths");
let repl_from = get_config( let repl_from = sql
context, .get_config(context, "backup_for", Some(as_str(context.get_blobdir())))
sql, .unwrap();
"backup_for",
Some(as_str(context.get_blobdir())),
)
.unwrap();
let repl_from = dc_ensure_no_slash_safe(&repl_from); let repl_from = dc_ensure_no_slash_safe(&repl_from);
sql.execute( sql.execute(
@@ -682,7 +810,7 @@ fn open(
NO_PARAMS, NO_PARAMS,
)?; )?;
set_config(context, sql, "backup_for", None); sql.set_config(context, "backup_for", None);
} }
} }
@@ -691,76 +819,6 @@ fn open(
Ok(()) Ok(())
} }
// handle configurations, private
pub fn set_config(
context: &Context,
sql: &Sql,
key: impl AsRef<str>,
value: Option<&str>,
) -> libc::c_int {
if !sql.is_open() {
error!(context, 0, "set_config(): Database not ready.");
return 0;
}
let key = key.as_ref();
let good;
if let Some(ref value) = value {
let exists = sql
.exists("SELECT value FROM config WHERE keyname=?;", params![key])
.unwrap_or_default();
if exists {
good = execute(
context,
sql,
"UPDATE config SET value=? WHERE keyname=?;",
params![value, key],
);
} else {
good = execute(
context,
sql,
"INSERT INTO config (keyname, value) VALUES (?, ?);",
params![key, value],
);
}
} else {
good = execute(
context,
sql,
"DELETE FROM config WHERE keyname=?;",
params![key],
);
}
if !good {
error!(context, 0, "set_config(): Cannot change value.",);
return 0;
}
1
}
pub fn get_config(
context: &Context,
sql: &Sql,
key: impl AsRef<str>,
def: Option<&str>,
) -> Option<String> {
if !sql.is_open() || key.as_ref().is_empty() {
return None;
}
query_row(
context,
sql,
"SELECT value FROM config WHERE keyname=?;",
params![key.as_ref()],
0,
)
.or_else(|| def.map(|s| s.to_string()))
}
pub fn execute<P>(context: &Context, sql: &Sql, querystr: impl AsRef<str>, params: P) -> bool pub fn execute<P>(context: &Context, sql: &Sql, querystr: impl AsRef<str>, params: P) -> bool
where where
P: IntoIterator, P: IntoIterator,
@@ -781,67 +839,6 @@ where
} }
} }
// TODO Remove the Option<> from the return type.
pub fn query_row<P, T>(
context: &Context,
sql: &Sql,
query: &str,
params: P,
column: usize,
) -> Option<T>
where
P: IntoIterator,
P::Item: rusqlite::ToSql,
T: rusqlite::types::FromSql,
{
match sql.query_row(query, params, |row| row.get::<_, T>(column)) {
Ok(res) => Some(res),
Err(Error::Sql(rusqlite::Error::QueryReturnedNoRows)) => None,
Err(Error::Sql(rusqlite::Error::InvalidColumnType(_, _, rusqlite::types::Type::Null))) => {
None
}
Err(err) => {
error!(context, 0, "sql: Failed query_row: {}", err);
None
}
}
}
pub fn set_config_int(
context: &Context,
sql: &Sql,
key: impl AsRef<str>,
value: i32,
) -> libc::c_int {
set_config(context, sql, key, Some(&format!("{}", value)))
}
pub fn get_config_int(context: &Context, sql: &Sql, key: impl AsRef<str>, def: i32) -> i32 {
get_config(context, sql, key, None)
.and_then(|s| s.parse().ok())
.unwrap_or_else(|| def)
}
pub fn set_config_int64(
context: &Context,
sql: &Sql,
key: impl AsRef<str>,
value: i64,
) -> libc::c_int {
set_config(context, sql, key, Some(&format!("{}", value)))
}
pub fn get_config_int64(
context: &Context,
sql: &Sql,
key: impl AsRef<str>,
def: Option<i64>,
) -> i64 {
let ret = get_config(context, sql, key, None);
ret.map(|r| r.parse().unwrap_or_default())
.unwrap_or_else(|| def.unwrap_or_default())
}
pub fn try_execute(context: &Context, sql: &Sql, querystr: impl AsRef<str>) -> libc::c_int { pub fn try_execute(context: &Context, sql: &Sql, querystr: impl AsRef<str>) -> libc::c_int {
// same as execute() but does not pass error to ui // same as execute() but does not pass error to ui
match sql.execute(querystr.as_ref(), params![]) { match sql.execute(querystr.as_ref(), params![]) {