mirror of
https://github.com/chatmail/core.git
synced 2026-04-17 21:46:35 +03:00
f31f603c8b
This marks the function safe and returns Result, it also now returns the ConfiguredAddr since it has to look this up anyway and it makes testing more easy. Turns out it reduces some duplicate SQL query in some callers too. More test code has been moved from dc_imex to test_utils as it's more genrally applicable.
1174 lines
42 KiB
Rust
1174 lines
42 KiB
Rust
use std::ffi::CString;
|
|
use std::str::FromStr;
|
|
|
|
use deltachat::chatlist::*;
|
|
use deltachat::config;
|
|
use deltachat::constants::*;
|
|
use deltachat::contact::*;
|
|
use deltachat::context::*;
|
|
use deltachat::dc_array::*;
|
|
use deltachat::dc_chat::*;
|
|
use deltachat::dc_configure::*;
|
|
use deltachat::dc_imex::*;
|
|
use deltachat::dc_job::*;
|
|
use deltachat::dc_location::*;
|
|
use deltachat::dc_lot::*;
|
|
use deltachat::dc_msg::*;
|
|
use deltachat::dc_qr::*;
|
|
use deltachat::dc_receive_imf::*;
|
|
use deltachat::dc_tools::*;
|
|
use deltachat::peerstate::*;
|
|
use deltachat::sql;
|
|
use deltachat::types::*;
|
|
use deltachat::x::*;
|
|
use num_traits::FromPrimitive;
|
|
|
|
/// Reset database tables. This function is called from Core cmdline.
|
|
/// Argument is a bitmask, executing single or multiple actions in one call.
|
|
/// e.g. bitmask 7 triggers actions definded with bits 1, 2 and 4.
|
|
pub unsafe fn dc_reset_tables(context: &Context, bits: i32) -> i32 {
|
|
info!(context, 0, "Resetting tables ({})...", bits);
|
|
if 0 != bits & 1 {
|
|
sql::execute(context, &context.sql, "DELETE FROM jobs;", params![]).unwrap();
|
|
info!(context, 0, "(1) Jobs reset.");
|
|
}
|
|
if 0 != bits & 2 {
|
|
sql::execute(
|
|
context,
|
|
&context.sql,
|
|
"DELETE FROM acpeerstates;",
|
|
params![],
|
|
)
|
|
.unwrap();
|
|
info!(context, 0, "(2) Peerstates reset.");
|
|
}
|
|
if 0 != bits & 4 {
|
|
sql::execute(context, &context.sql, "DELETE FROM keypairs;", params![]).unwrap();
|
|
info!(context, 0, "(4) Private keypairs reset.");
|
|
}
|
|
if 0 != bits & 8 {
|
|
sql::execute(
|
|
context,
|
|
&context.sql,
|
|
"DELETE FROM contacts WHERE id>9;",
|
|
params![],
|
|
)
|
|
.unwrap();
|
|
sql::execute(
|
|
context,
|
|
&context.sql,
|
|
"DELETE FROM chats WHERE id>9;",
|
|
params![],
|
|
)
|
|
.unwrap();
|
|
sql::execute(
|
|
context,
|
|
&context.sql,
|
|
"DELETE FROM chats_contacts;",
|
|
params![],
|
|
)
|
|
.unwrap();
|
|
sql::execute(
|
|
context,
|
|
&context.sql,
|
|
"DELETE FROM msgs WHERE id>9;",
|
|
params![],
|
|
)
|
|
.unwrap();
|
|
sql::execute(
|
|
context,
|
|
&context.sql,
|
|
"DELETE FROM config WHERE keyname LIKE 'imap.%' OR keyname LIKE 'configured%';",
|
|
params![],
|
|
)
|
|
.unwrap();
|
|
sql::execute(context, &context.sql, "DELETE FROM leftgrps;", params![]).unwrap();
|
|
info!(context, 0, "(8) Rest but server config reset.");
|
|
}
|
|
|
|
context.call_cb(Event::MSGS_CHANGED, 0, 0);
|
|
|
|
1
|
|
}
|
|
|
|
unsafe fn dc_poke_eml_file(context: &Context, filename: *const libc::c_char) -> libc::c_int {
|
|
/* mainly for testing, may be called by dc_import_spec() */
|
|
let mut success: libc::c_int = 0i32;
|
|
let mut data: *mut libc::c_char = 0 as *mut libc::c_char;
|
|
let mut data_bytes: size_t = 0;
|
|
if !(dc_read_file(
|
|
context,
|
|
filename,
|
|
&mut data as *mut *mut libc::c_char as *mut *mut libc::c_void,
|
|
&mut data_bytes,
|
|
) == 0i32)
|
|
{
|
|
dc_receive_imf(context, data, data_bytes, "import", 0, 0);
|
|
success = 1;
|
|
}
|
|
free(data as *mut libc::c_void);
|
|
|
|
success
|
|
}
|
|
|
|
/// Import a file to the database.
|
|
/// For testing, import a folder with eml-files, a single eml-file, e-mail plus public key and so on.
|
|
/// For normal importing, use dc_imex().
|
|
///
|
|
/// @private @memberof Context
|
|
/// @param context The context as created by dc_context_new().
|
|
/// @param spec The file or directory to import. NULL for the last command.
|
|
/// @return 1=success, 0=error.
|
|
unsafe fn poke_spec(context: &Context, spec: *const libc::c_char) -> libc::c_int {
|
|
if !context.sql.is_open() {
|
|
error!(context, 0, "Import: Database not opened.");
|
|
return 0;
|
|
}
|
|
|
|
let mut current_block: u64;
|
|
let mut success: libc::c_int = 0;
|
|
let real_spec: *mut libc::c_char;
|
|
let mut suffix: *mut libc::c_char = 0 as *mut libc::c_char;
|
|
let mut read_cnt: libc::c_int = 0;
|
|
|
|
/* if `spec` is given, remember it for later usage; if it is not given, try to use the last one */
|
|
if !spec.is_null() {
|
|
real_spec = dc_strdup(spec);
|
|
context
|
|
.sql
|
|
.set_config(context, "import_spec", Some(as_str(real_spec)))
|
|
.unwrap();
|
|
current_block = 7149356873433890176;
|
|
} else {
|
|
let rs = context.sql.get_config(context, "import_spec");
|
|
if rs.is_none() {
|
|
error!(context, 0, "Import: No file or folder given.");
|
|
current_block = 8522321847195001863;
|
|
} else {
|
|
current_block = 7149356873433890176;
|
|
}
|
|
real_spec = rs.unwrap_or_default().strdup();
|
|
}
|
|
match current_block {
|
|
8522321847195001863 => {}
|
|
_ => {
|
|
suffix = dc_get_filesuffix_lc(real_spec);
|
|
if !suffix.is_null()
|
|
&& strcmp(suffix, b"eml\x00" as *const u8 as *const libc::c_char) == 0
|
|
{
|
|
if 0 != dc_poke_eml_file(context, real_spec) {
|
|
read_cnt += 1
|
|
}
|
|
current_block = 1622411330066726685;
|
|
} else {
|
|
/* import a directory */
|
|
let dir_name = std::path::Path::new(as_str(real_spec));
|
|
let dir = std::fs::read_dir(dir_name);
|
|
if dir.is_err() {
|
|
error!(
|
|
context,
|
|
0,
|
|
"Import: Cannot open directory \"{}\".",
|
|
as_str(real_spec),
|
|
);
|
|
current_block = 8522321847195001863;
|
|
} else {
|
|
let dir = dir.unwrap();
|
|
for entry in dir {
|
|
if entry.is_err() {
|
|
break;
|
|
}
|
|
let entry = entry.unwrap();
|
|
let name_f = entry.file_name();
|
|
let name = name_f.to_string_lossy();
|
|
if name.ends_with(".eml") {
|
|
let path_plus_name = format!("{}/{}", as_str(real_spec), name);
|
|
info!(context, 0, "Import: {}", path_plus_name);
|
|
let path_plus_name_c = CString::yolo(path_plus_name);
|
|
if 0 != dc_poke_eml_file(context, path_plus_name_c.as_ptr()) {
|
|
read_cnt += 1
|
|
}
|
|
}
|
|
}
|
|
current_block = 1622411330066726685;
|
|
}
|
|
}
|
|
match current_block {
|
|
8522321847195001863 => {}
|
|
_ => {
|
|
info!(
|
|
context,
|
|
0,
|
|
"Import: {} items read from \"{}\".",
|
|
read_cnt,
|
|
as_str(real_spec)
|
|
);
|
|
if read_cnt > 0 {
|
|
context.call_cb(Event::MSGS_CHANGED, 0 as uintptr_t, 0 as uintptr_t);
|
|
}
|
|
success = 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
free(real_spec as *mut libc::c_void);
|
|
free(suffix as *mut libc::c_void);
|
|
success
|
|
}
|
|
|
|
unsafe fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: *mut dc_msg_t) {
|
|
let contact = Contact::get_by_id(context, dc_msg_get_from_id(msg)).expect("invalid contact");
|
|
let contact_name = contact.get_name();
|
|
let contact_id = contact.get_id();
|
|
|
|
let statestr = match dc_msg_get_state(msg) {
|
|
DC_STATE_OUT_PENDING => " o",
|
|
DC_STATE_OUT_DELIVERED => " √",
|
|
DC_STATE_OUT_MDN_RCVD => " √√",
|
|
DC_STATE_OUT_FAILED => " !!",
|
|
_ => "",
|
|
};
|
|
let temp2 = dc_timestamp_to_str(dc_msg_get_timestamp(msg));
|
|
let msgtext = dc_msg_get_text(msg);
|
|
info!(
|
|
context,
|
|
0,
|
|
"{}#{}{}{}: {} (Contact#{}): {} {}{}{}{} [{}]",
|
|
prefix.as_ref(),
|
|
dc_msg_get_id(msg) as libc::c_int,
|
|
if 0 != dc_msg_get_showpadlock(msg) {
|
|
"🔒"
|
|
} else {
|
|
""
|
|
},
|
|
if dc_msg_has_location(msg) { "📍" } else { "" },
|
|
&contact_name,
|
|
contact_id,
|
|
as_str(msgtext),
|
|
if dc_msg_is_starred(msg) { "★" } else { "" },
|
|
if dc_msg_get_from_id(msg) == 1 as libc::c_uint {
|
|
""
|
|
} else if dc_msg_get_state(msg) == DC_STATE_IN_SEEN {
|
|
"[SEEN]"
|
|
} else if dc_msg_get_state(msg) == DC_STATE_IN_NOTICED {
|
|
"[NOTICED]"
|
|
} else {
|
|
"[FRESH]"
|
|
},
|
|
if 0 != dc_msg_is_info(msg) {
|
|
"[INFO]"
|
|
} else {
|
|
""
|
|
},
|
|
statestr,
|
|
&temp2,
|
|
);
|
|
free(msgtext as *mut libc::c_void);
|
|
}
|
|
|
|
unsafe fn log_msglist(context: &Context, msglist: *mut dc_array_t) {
|
|
let cnt = dc_array_get_cnt(msglist) as usize;
|
|
let mut lines_out = 0;
|
|
for i in 0..cnt {
|
|
let msg_id = dc_array_get_id(msglist, i as size_t);
|
|
if msg_id == 9 as libc::c_uint {
|
|
info!(
|
|
context,
|
|
0,
|
|
"--------------------------------------------------------------------------------"
|
|
);
|
|
|
|
lines_out += 1
|
|
} else if msg_id > 0 as libc::c_uint {
|
|
if lines_out == 0 {
|
|
info!(
|
|
context, 0,
|
|
"--------------------------------------------------------------------------------",
|
|
);
|
|
lines_out += 1
|
|
}
|
|
let msg = dc_get_msg(context, msg_id);
|
|
log_msg(context, "Msg", msg);
|
|
dc_msg_unref(msg);
|
|
}
|
|
}
|
|
if lines_out > 0 {
|
|
info!(
|
|
context,
|
|
0, "--------------------------------------------------------------------------------"
|
|
);
|
|
}
|
|
}
|
|
|
|
unsafe fn log_contactlist(context: &Context, contacts: *mut dc_array_t) {
|
|
if !dc_array_search_id(contacts, 1 as uint32_t, 0 as *mut size_t) {
|
|
dc_array_add_id(contacts, 1 as uint32_t);
|
|
}
|
|
let cnt = dc_array_get_cnt(contacts);
|
|
for i in 0..cnt {
|
|
let contact_id = dc_array_get_id(contacts, i as size_t);
|
|
let line;
|
|
let mut line2 = "".to_string();
|
|
if let Ok(contact) = Contact::get_by_id(context, contact_id) {
|
|
let name = contact.get_name();
|
|
let addr = contact.get_addr();
|
|
let verified_state = contact.is_verified();
|
|
let verified_str = if VerifiedStatus::Unverified != verified_state {
|
|
if verified_state == VerifiedStatus::BidirectVerified {
|
|
" √√"
|
|
} else {
|
|
" √"
|
|
}
|
|
} else {
|
|
""
|
|
};
|
|
line = format!(
|
|
"{}{} <{}>",
|
|
if !name.is_empty() {
|
|
&name
|
|
} else {
|
|
"<name unset>"
|
|
},
|
|
verified_str,
|
|
if !addr.is_empty() {
|
|
&addr
|
|
} else {
|
|
"addr unset"
|
|
}
|
|
);
|
|
let peerstate = Peerstate::from_addr(context, &context.sql, &addr);
|
|
if peerstate.is_some() && contact_id != 1 as libc::c_uint {
|
|
line2 = format!(
|
|
", prefer-encrypt={}",
|
|
peerstate.as_ref().unwrap().prefer_encrypt
|
|
);
|
|
}
|
|
|
|
info!(context, 0, "Contact#{}: {}{}", contact_id, line, line2);
|
|
}
|
|
}
|
|
}
|
|
|
|
static mut S_IS_AUTH: libc::c_int = 0;
|
|
|
|
pub unsafe fn dc_cmdline_skip_auth() {
|
|
S_IS_AUTH = 1;
|
|
}
|
|
|
|
unsafe fn chat_prefix(chat: *const Chat) -> &'static str {
|
|
if (*chat).type_0 == 120 {
|
|
"Group"
|
|
} else if (*chat).type_0 == 130 {
|
|
"VerifiedGroup"
|
|
} else {
|
|
"Single"
|
|
}
|
|
}
|
|
|
|
pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::Error> {
|
|
let chat_id = *context.cmdline_sel_chat_id.read().unwrap();
|
|
let mut sel_chat = if chat_id > 0 {
|
|
dc_get_chat(context, chat_id)
|
|
} else {
|
|
std::ptr::null_mut()
|
|
};
|
|
|
|
let mut args = line.splitn(3, ' ');
|
|
let arg0 = args.next().unwrap_or_default();
|
|
let arg1 = args.next().unwrap_or_default();
|
|
let arg1_c = if arg1.is_empty() {
|
|
std::ptr::null()
|
|
} else {
|
|
arg1.strdup() as *const _
|
|
};
|
|
let arg2 = args.next().unwrap_or_default();
|
|
let arg2_c = if arg2.is_empty() {
|
|
std::ptr::null()
|
|
} else {
|
|
arg2.strdup() as *const _
|
|
};
|
|
|
|
match arg0 {
|
|
"help" | "?" => match arg1 {
|
|
// TODO: reuse commands definition in main.rs.
|
|
"imex" => println!(
|
|
"====================Import/Export commands==\n\
|
|
initiate-key-transfer\n\
|
|
get-setupcodebegin <msg-id>\n\
|
|
continue-key-transfer <msg-id> <setup-code>\n\
|
|
has-backup\n\
|
|
export-backup\n\
|
|
import-backup <backup-file>\n\
|
|
export-keys\n\
|
|
import-keys\n\
|
|
export-setup\n\
|
|
poke [<eml-file>|<folder>|<addr> <key-file>]\n\
|
|
reset <flags>\n\
|
|
stop\n\
|
|
============================================="
|
|
),
|
|
_ => println!(
|
|
"==========================Database commands==\n\
|
|
info\n\
|
|
open <file to open or create>\n\
|
|
close\n\
|
|
set <configuration-key> [<value>]\n\
|
|
get <configuration-key>\n\
|
|
oauth2\n\
|
|
configure\n\
|
|
connect\n\
|
|
disconnect\n\
|
|
maybenetwork\n\
|
|
housekeeping\n\
|
|
help imex (Import/Export)\n\
|
|
==============================Chat commands==\n\
|
|
listchats [<query>]\n\
|
|
listarchived\n\
|
|
chat [<chat-id>|0]\n\
|
|
createchat <contact-id>\n\
|
|
createchatbymsg <msg-id>\n\
|
|
creategroup <name>\n\
|
|
createverified <name>\n\
|
|
addmember <contact-id>\n\
|
|
removemember <contact-id>\n\
|
|
groupname <name>\n\
|
|
groupimage [<file>]\n\
|
|
chatinfo\n\
|
|
sendlocations <seconds>\n\
|
|
setlocation <lat> <lng>\n\
|
|
dellocations\n\
|
|
getlocations [<contact-id>]\n\
|
|
send <text>\n\
|
|
send-garbage\n\
|
|
sendimage <file> [<text>]\n\
|
|
sendfile <file>\n\
|
|
draft [<text>]\n\
|
|
listmedia\n\
|
|
archive <chat-id>\n\
|
|
unarchive <chat-id>\n\
|
|
delchat <chat-id>\n\
|
|
===========================Message commands==\n\
|
|
listmsgs <query>\n\
|
|
msginfo <msg-id>\n\
|
|
listfresh\n\
|
|
forward <msg-id> <chat-id>\n\
|
|
markseen <msg-id>\n\
|
|
star <msg-id>\n\
|
|
unstar <msg-id>\n\
|
|
delmsg <msg-id>\n\
|
|
===========================Contact commands==\n\
|
|
listcontacts [<query>]\n\
|
|
listverified [<query>]\n\
|
|
addcontact [<name>] <addr>\n\
|
|
contactinfo <contact-id>\n\
|
|
delcontact <contact-id>\n\
|
|
cleanupcontacts\n\
|
|
======================================Misc.==\n\
|
|
getqr [<chat-id>]\n\
|
|
getbadqr\n\
|
|
checkqr <qr-content>\n\
|
|
event <event-id to test>\n\
|
|
fileinfo <file>\n\
|
|
clear -- clear screen\n\
|
|
exit\n\
|
|
============================================="
|
|
),
|
|
},
|
|
"auth" => {
|
|
if 0 == S_IS_AUTH {
|
|
let is_pw = context
|
|
.get_config(config::Config::MailPw)
|
|
.unwrap_or_default();
|
|
if arg1 == is_pw {
|
|
S_IS_AUTH = 1;
|
|
} else {
|
|
println!("Bad password.");
|
|
}
|
|
} else {
|
|
println!("Already authorized.");
|
|
}
|
|
}
|
|
"open" => {
|
|
ensure!(!arg1.is_empty(), "Argument <file> missing");
|
|
dc_close(context);
|
|
ensure!(dc_open(context, arg1, None), "Open failed");
|
|
}
|
|
"close" => {
|
|
dc_close(context);
|
|
}
|
|
"initiate-key-transfer" => {
|
|
let setup_code = dc_initiate_key_transfer(context);
|
|
if !setup_code.is_null() {
|
|
println!(
|
|
"Setup code for the transferred setup message: {}",
|
|
as_str(setup_code),
|
|
);
|
|
free(setup_code as *mut libc::c_void);
|
|
} else {
|
|
bail!("Failed to generate setup code");
|
|
};
|
|
}
|
|
"get-setupcodebegin" => {
|
|
ensure!(!arg1.is_empty(), "Argument <msg-id> missing.");
|
|
let msg_id: u32 = arg1.parse()?;
|
|
let msg: *mut dc_msg_t = dc_get_msg(context, msg_id);
|
|
if dc_msg_is_setupmessage(msg) {
|
|
let setupcodebegin = dc_msg_get_setupcodebegin(msg);
|
|
println!(
|
|
"The setup code for setup message Msg#{} starts with: {}",
|
|
msg_id,
|
|
as_str(setupcodebegin),
|
|
);
|
|
free(setupcodebegin as *mut libc::c_void);
|
|
} else {
|
|
bail!("Msg#{} is no setup message.", msg_id,);
|
|
}
|
|
dc_msg_unref(msg);
|
|
}
|
|
"continue-key-transfer" => {
|
|
ensure!(
|
|
!arg1.is_empty() && !arg2.is_empty(),
|
|
"Arguments <msg-id> <setup-code> expected"
|
|
);
|
|
if 0 == dc_continue_key_transfer(context, arg1.parse()?, arg2_c) {
|
|
bail!("Continue key transfer failed");
|
|
}
|
|
}
|
|
"has-backup" => {
|
|
let ret = dc_imex_has_backup(context, context.get_blobdir());
|
|
if ret.is_null() {
|
|
println!("No backup found.");
|
|
}
|
|
}
|
|
"export-backup" => {
|
|
dc_imex(context, 11, context.get_blobdir(), 0 as *const libc::c_char);
|
|
}
|
|
"import-backup" => {
|
|
ensure!(!arg1.is_empty(), "Argument <backup-file> missing.");
|
|
dc_imex(context, 12, arg1_c, 0 as *const libc::c_char);
|
|
}
|
|
"export-keys" => {
|
|
dc_imex(context, 1, context.get_blobdir(), 0 as *const libc::c_char);
|
|
}
|
|
"import-keys" => {
|
|
dc_imex(context, 2, context.get_blobdir(), 0 as *const libc::c_char);
|
|
}
|
|
"export-setup" => {
|
|
let setup_code = dc_create_setup_code(context);
|
|
let file_name: *mut libc::c_char = dc_mprintf(
|
|
b"%s/autocrypt-setup-message.html\x00" as *const u8 as *const libc::c_char,
|
|
context.get_blobdir(),
|
|
);
|
|
let file_content = dc_render_setup_file(context, &setup_code)?;
|
|
std::fs::write(as_str(file_name), file_content)?;
|
|
println!(
|
|
"Setup message written to: {}\nSetup code: {}",
|
|
as_str(file_name),
|
|
&setup_code,
|
|
);
|
|
free(file_name as *mut libc::c_void);
|
|
}
|
|
"poke" => {
|
|
ensure!(0 != poke_spec(context, arg1_c), "Poke failed");
|
|
}
|
|
"reset" => {
|
|
ensure!(!arg1.is_empty(), "Argument <bits> missing: 1=jobs, 2=peerstates, 4=private keys, 8=rest but server config");
|
|
let bits: i32 = arg1.parse()?;
|
|
ensure!(bits < 16, "<bits> must be lower than 16.");
|
|
ensure!(0 != dc_reset_tables(context, bits), "Reset failed");
|
|
}
|
|
"stop" => {
|
|
dc_stop_ongoing_process(context);
|
|
}
|
|
"set" => {
|
|
ensure!(!arg1.is_empty(), "Argument <key> missing.");
|
|
let key = config::Config::from_str(&arg1)?;
|
|
let value = if arg2.is_empty() { None } else { Some(arg2) };
|
|
context.set_config(key, value)?;
|
|
}
|
|
"get" => {
|
|
ensure!(!arg1.is_empty(), "Argument <key> missing.");
|
|
let key = config::Config::from_str(&arg1)?;
|
|
let val = context.get_config(key);
|
|
println!("{}={:?}", key, val);
|
|
}
|
|
"info" => {
|
|
println!("{}", to_string(dc_get_info(context)));
|
|
}
|
|
"maybenetwork" => {
|
|
dc_maybe_network(context);
|
|
}
|
|
"housekeeping" => {
|
|
sql::housekeeping(context);
|
|
}
|
|
"listchats" | "listarchived" | "chats" => {
|
|
let listflags = if arg0 == "listarchived" { 0x01 } else { 0 };
|
|
let chatlist = Chatlist::try_load(context, listflags, Some(arg1), None)?;
|
|
|
|
let mut i: usize;
|
|
let cnt = chatlist.len();
|
|
if cnt > 0 {
|
|
info!(
|
|
context, 0,
|
|
"================================================================================"
|
|
);
|
|
|
|
i = cnt - 1;
|
|
|
|
while i > 0 {
|
|
let chat = dc_get_chat(context, chatlist.get_chat_id(i));
|
|
let temp_subtitle = dc_chat_get_subtitle(chat);
|
|
let temp_name = dc_chat_get_name(chat);
|
|
info!(
|
|
context,
|
|
0,
|
|
"{}#{}: {} [{}] [{} fresh]",
|
|
chat_prefix(chat),
|
|
dc_chat_get_id(chat) as libc::c_int,
|
|
as_str(temp_name),
|
|
as_str(temp_subtitle),
|
|
dc_get_fresh_msg_cnt(context, dc_chat_get_id(chat)) as libc::c_int,
|
|
);
|
|
free(temp_subtitle as *mut libc::c_void);
|
|
free(temp_name as *mut libc::c_void);
|
|
let lot = chatlist.get_summary(i, chat);
|
|
let statestr = if 0 != dc_chat_get_archived(chat) {
|
|
" [Archived]"
|
|
} else {
|
|
match dc_lot_get_state(lot) {
|
|
20 => " o",
|
|
26 => " √",
|
|
28 => " √√",
|
|
24 => " !!",
|
|
_ => "",
|
|
}
|
|
};
|
|
let timestr = dc_timestamp_to_str(dc_lot_get_timestamp(lot));
|
|
let text1 = dc_lot_get_text1(lot);
|
|
let text2 = dc_lot_get_text2(lot);
|
|
info!(
|
|
context,
|
|
0,
|
|
"{}{}{}{} [{}]{}",
|
|
to_string(text1),
|
|
if !text1.is_null() { ": " } else { "" },
|
|
to_string(text2),
|
|
statestr,
|
|
×tr,
|
|
if 0 != dc_chat_is_sending_locations(chat) {
|
|
"📍"
|
|
} else {
|
|
""
|
|
},
|
|
);
|
|
free(text1 as *mut libc::c_void);
|
|
free(text2 as *mut libc::c_void);
|
|
dc_lot_unref(lot);
|
|
dc_chat_unref(chat);
|
|
info!(
|
|
context, 0,
|
|
"================================================================================"
|
|
);
|
|
|
|
i -= 1
|
|
}
|
|
}
|
|
if dc_is_sending_locations_to_chat(context, 0 as uint32_t) {
|
|
info!(context, 0, "Location streaming enabled.");
|
|
}
|
|
println!("{} chats", cnt);
|
|
}
|
|
"chat" => {
|
|
if sel_chat.is_null() && arg1.is_empty() {
|
|
bail!("Argument [chat-id] is missing.");
|
|
}
|
|
if !sel_chat.is_null() && !arg1.is_empty() {
|
|
dc_chat_unref(sel_chat);
|
|
}
|
|
if !arg1.is_empty() {
|
|
let chat_id = arg1.parse()?;
|
|
println!("Selecting chat #{}", chat_id);
|
|
sel_chat = dc_get_chat(context, chat_id);
|
|
*context.cmdline_sel_chat_id.write().unwrap() = chat_id;
|
|
}
|
|
|
|
ensure!(!sel_chat.is_null(), "Failed to select chat");
|
|
|
|
let msglist = dc_get_chat_msgs(context, dc_chat_get_id(sel_chat), 0x1, 0);
|
|
let temp2 = dc_chat_get_subtitle(sel_chat);
|
|
let temp_name = dc_chat_get_name(sel_chat);
|
|
info!(
|
|
context,
|
|
0,
|
|
"{}#{}: {} [{}]{}",
|
|
chat_prefix(sel_chat),
|
|
dc_chat_get_id(sel_chat),
|
|
as_str(temp_name),
|
|
as_str(temp2),
|
|
if 0 != dc_chat_is_sending_locations(sel_chat) {
|
|
"📍"
|
|
} else {
|
|
""
|
|
},
|
|
);
|
|
free(temp_name as *mut libc::c_void);
|
|
free(temp2 as *mut libc::c_void);
|
|
if !msglist.is_null() {
|
|
log_msglist(context, msglist);
|
|
dc_array_unref(msglist);
|
|
}
|
|
let draft = dc_get_draft(context, dc_chat_get_id(sel_chat));
|
|
if !draft.is_null() {
|
|
log_msg(context, "Draft", draft);
|
|
dc_msg_unref(draft);
|
|
}
|
|
println!(
|
|
"{} messages.",
|
|
dc_get_msg_cnt(context, dc_chat_get_id(sel_chat))
|
|
);
|
|
dc_marknoticed_chat(context, dc_chat_get_id(sel_chat));
|
|
}
|
|
"createchat" => {
|
|
ensure!(!arg1.is_empty(), "Argument <contact-id> missing.");
|
|
let contact_id: libc::c_int = arg1.parse()?;
|
|
let chat_id: libc::c_int =
|
|
dc_create_chat_by_contact_id(context, contact_id as uint32_t) as libc::c_int;
|
|
if chat_id != 0 {
|
|
println!("Single#{} created successfully.", chat_id,);
|
|
} else {
|
|
bail!("Failed to create chat");
|
|
}
|
|
}
|
|
"createchatbymsg" => {
|
|
ensure!(!arg1.is_empty(), "Argument <msg-id> missing");
|
|
let msg_id_0: libc::c_int = arg1.parse()?;
|
|
let chat_id_0: libc::c_int =
|
|
dc_create_chat_by_msg_id(context, msg_id_0 as uint32_t) as libc::c_int;
|
|
if chat_id_0 != 0 {
|
|
let chat_0: *mut Chat = dc_get_chat(context, chat_id_0 as uint32_t);
|
|
println!(
|
|
"{}#{} created successfully.",
|
|
chat_prefix(chat_0),
|
|
chat_id_0,
|
|
);
|
|
dc_chat_unref(chat_0);
|
|
} else {
|
|
bail!("");
|
|
}
|
|
}
|
|
"creategroup" => {
|
|
ensure!(!arg1.is_empty(), "Argument <name> missing.");
|
|
let chat_id_1: libc::c_int = dc_create_group_chat(context, 0, arg1_c) as libc::c_int;
|
|
if chat_id_1 != 0 {
|
|
println!("Group#{} created successfully.", chat_id_1,);
|
|
} else {
|
|
bail!("Failed to create group");
|
|
}
|
|
}
|
|
"createverified" => {
|
|
ensure!(!arg1.is_empty(), "Argument <name> missing.");
|
|
let chat_id_2: libc::c_int = dc_create_group_chat(context, 1, arg1_c) as libc::c_int;
|
|
if chat_id_2 != 0 {
|
|
println!("VerifiedGroup#{} created successfully.", chat_id_2,);
|
|
} else {
|
|
bail!("Failed to create verified group");
|
|
}
|
|
}
|
|
"addmember" => {
|
|
ensure!(!sel_chat.is_null(), "No chat selected");
|
|
ensure!(!arg1.is_empty(), "Argument <contact-id> missing.");
|
|
|
|
let contact_id_0: libc::c_int = arg1.parse()?;
|
|
if 0 != dc_add_contact_to_chat(
|
|
context,
|
|
dc_chat_get_id(sel_chat),
|
|
contact_id_0 as uint32_t,
|
|
) {
|
|
println!("Contact added to chat.");
|
|
} else {
|
|
bail!("Cannot add contact to chat.");
|
|
}
|
|
}
|
|
"removemember" => {
|
|
ensure!(!sel_chat.is_null(), "No chat selected.");
|
|
ensure!(!arg1.is_empty(), "Argument <contact-id> missing.");
|
|
let contact_id_1: libc::c_int = arg1.parse()?;
|
|
if 0 != dc_remove_contact_from_chat(
|
|
context,
|
|
dc_chat_get_id(sel_chat),
|
|
contact_id_1 as uint32_t,
|
|
) {
|
|
println!("Contact added to chat.");
|
|
} else {
|
|
bail!("Cannot remove member from chat.");
|
|
}
|
|
}
|
|
"groupname" => {
|
|
ensure!(!sel_chat.is_null(), "No chat selected.");
|
|
ensure!(!arg1.is_empty(), "Argument <name> missing.");
|
|
if 0 != dc_set_chat_name(context, dc_chat_get_id(sel_chat), arg1_c) {
|
|
println!("Chat name set");
|
|
} else {
|
|
bail!("Failed to set chat name");
|
|
}
|
|
}
|
|
"groupimage" => {
|
|
ensure!(!sel_chat.is_null(), "No chat selected.");
|
|
ensure!(!arg1.is_empty(), "Argument <image> missing.");
|
|
|
|
if 0 != dc_set_chat_profile_image(
|
|
context,
|
|
dc_chat_get_id(sel_chat),
|
|
if !arg1.is_empty() {
|
|
arg1_c
|
|
} else {
|
|
std::ptr::null_mut()
|
|
},
|
|
) {
|
|
println!("Chat image set");
|
|
} else {
|
|
bail!("Failed to set chat image");
|
|
}
|
|
}
|
|
"chatinfo" => {
|
|
ensure!(!sel_chat.is_null(), "No chat selected.");
|
|
|
|
let contacts = dc_get_chat_contacts(context, dc_chat_get_id(sel_chat));
|
|
ensure!(!contacts.is_null(), "Failed to retreive contacts");
|
|
info!(context, 0, "Memberlist:");
|
|
|
|
log_contactlist(context, contacts);
|
|
println!(
|
|
"{} contacts\nLocation streaming: {}",
|
|
dc_array_get_cnt(contacts),
|
|
dc_is_sending_locations_to_chat(context, dc_chat_get_id(sel_chat)),
|
|
);
|
|
dc_array_unref(contacts);
|
|
}
|
|
"getlocations" => {
|
|
let contact_id = arg1.parse().unwrap_or_default();
|
|
let loc = dc_get_locations(context, dc_chat_get_id(sel_chat), contact_id, 0, 0);
|
|
let mut j = 0;
|
|
while j < dc_array_get_cnt(loc) {
|
|
let timestr_0 = dc_timestamp_to_str(dc_array_get_timestamp(loc, j as size_t));
|
|
let marker = dc_array_get_marker(loc, j as size_t);
|
|
info!(
|
|
context,
|
|
0,
|
|
"Loc#{}: {}: lat={} lng={} acc={} Chat#{} Contact#{} Msg#{} {}",
|
|
dc_array_get_id(loc, j as size_t),
|
|
×tr_0,
|
|
dc_array_get_latitude(loc, j as size_t),
|
|
dc_array_get_longitude(loc, j as size_t),
|
|
dc_array_get_accuracy(loc, j as size_t),
|
|
dc_array_get_chat_id(loc, j as size_t),
|
|
dc_array_get_contact_id(loc, j as size_t),
|
|
dc_array_get_msg_id(loc, j as size_t),
|
|
if !marker.is_null() {
|
|
as_str(marker)
|
|
} else {
|
|
"-"
|
|
},
|
|
);
|
|
free(marker as *mut libc::c_void);
|
|
j += 1
|
|
}
|
|
if dc_array_get_cnt(loc) == 0 {
|
|
info!(context, 0, "No locations.");
|
|
}
|
|
dc_array_unref(loc);
|
|
}
|
|
"sendlocations" => {
|
|
ensure!(!sel_chat.is_null(), "No chat selected.");
|
|
ensure!(!arg1.is_empty(), "No timeout given.");
|
|
|
|
let seconds = arg1.parse()?;
|
|
dc_send_locations_to_chat(context, dc_chat_get_id(sel_chat), seconds);
|
|
println!("Locations will be sent to Chat#{} for {} seconds. Use 'setlocation <lat> <lng>' to play around.", dc_chat_get_id(sel_chat), seconds);
|
|
}
|
|
"setlocation" => {
|
|
ensure!(
|
|
!arg1.is_empty() && !arg2.is_empty(),
|
|
"Latitude or longitude not given."
|
|
);
|
|
let latitude = arg1.parse()?;
|
|
let longitude = arg2.parse()?;
|
|
|
|
let continue_streaming = dc_set_location(context, latitude, longitude, 0.);
|
|
if 0 != continue_streaming {
|
|
println!("Success, streaming should be continued.");
|
|
} else {
|
|
println!("Success, streaming can be stoppped.");
|
|
}
|
|
}
|
|
"dellocations" => {
|
|
dc_delete_all_locations(context);
|
|
}
|
|
"send" => {
|
|
ensure!(!sel_chat.is_null(), "No chat selected.");
|
|
ensure!(!arg1.is_empty(), "No message text given.");
|
|
|
|
let msg = format!("{} {}", arg1, arg2);
|
|
|
|
if 0 != dc_send_text_msg(context, dc_chat_get_id(sel_chat), msg) {
|
|
println!("Message sent.");
|
|
} else {
|
|
bail!("Sending failed.");
|
|
}
|
|
}
|
|
"sendempty" => {
|
|
ensure!(!sel_chat.is_null(), "No chat selected.");
|
|
if 0 != dc_send_text_msg(context, dc_chat_get_id(sel_chat), "".into()) {
|
|
println!("Message sent.");
|
|
} else {
|
|
bail!("Sending failed.");
|
|
}
|
|
}
|
|
"sendimage" | "sendfile" => {
|
|
ensure!(!sel_chat.is_null(), "No chat selected.");
|
|
ensure!(!arg1.is_empty() && !arg2.is_empty(), "No file given.");
|
|
|
|
let msg_0 = dc_msg_new(
|
|
context,
|
|
if arg0 == "sendimage" {
|
|
Viewtype::Image
|
|
} else {
|
|
Viewtype::File
|
|
},
|
|
);
|
|
dc_msg_set_file(msg_0, arg1_c, 0 as *const libc::c_char);
|
|
dc_msg_set_text(msg_0, arg2_c);
|
|
dc_send_msg(context, dc_chat_get_id(sel_chat), msg_0);
|
|
dc_msg_unref(msg_0);
|
|
}
|
|
"listmsgs" => {
|
|
ensure!(!arg1.is_empty(), "Argument <query> missing.");
|
|
|
|
let chat = if !sel_chat.is_null() {
|
|
dc_chat_get_id(sel_chat)
|
|
} else {
|
|
0 as libc::c_uint
|
|
};
|
|
|
|
let msglist_0 = dc_search_msgs(context, chat, arg1_c);
|
|
|
|
if !msglist_0.is_null() {
|
|
log_msglist(context, msglist_0);
|
|
println!("{} messages.", dc_array_get_cnt(msglist_0));
|
|
dc_array_unref(msglist_0);
|
|
}
|
|
}
|
|
"draft" => {
|
|
ensure!(!sel_chat.is_null(), "No chat selected.");
|
|
|
|
if !arg1.is_empty() {
|
|
let draft_0 = dc_msg_new(context, Viewtype::Text);
|
|
dc_msg_set_text(draft_0, arg1_c);
|
|
dc_set_draft(context, dc_chat_get_id(sel_chat), draft_0);
|
|
dc_msg_unref(draft_0);
|
|
println!("Draft saved.");
|
|
} else {
|
|
dc_set_draft(context, dc_chat_get_id(sel_chat), 0 as *mut dc_msg_t);
|
|
println!("Draft deleted.");
|
|
}
|
|
}
|
|
"listmedia" => {
|
|
ensure!(!sel_chat.is_null(), "No chat selected.");
|
|
|
|
let images = dc_get_chat_media(
|
|
context,
|
|
dc_chat_get_id(sel_chat),
|
|
Viewtype::Image,
|
|
Viewtype::Gif,
|
|
Viewtype::Video,
|
|
);
|
|
let icnt: libc::c_int = dc_array_get_cnt(images) as libc::c_int;
|
|
println!("{} images or videos: ", icnt);
|
|
for i in 0..icnt {
|
|
let data = dc_array_get_id(images, i as size_t);
|
|
if 0 == i {
|
|
print!("Msg#{}", data);
|
|
} else {
|
|
print!(", Msg#{}", data);
|
|
}
|
|
}
|
|
print!("\n");
|
|
dc_array_unref(images);
|
|
}
|
|
"archive" | "unarchive" => {
|
|
ensure!(!arg1.is_empty(), "Argument <chat-id> missing.");
|
|
let chat_id = arg1.parse()?;
|
|
dc_archive_chat(context, chat_id, if arg0 == "archive" { 1 } else { 0 });
|
|
}
|
|
"delchat" => {
|
|
ensure!(!arg1.is_empty(), "Argument <chat-id> missing.");
|
|
let chat_id = arg1.parse()?;
|
|
dc_delete_chat(context, chat_id);
|
|
}
|
|
"msginfo" => {
|
|
ensure!(!arg1.is_empty(), "Argument <msg-id> missing.");
|
|
let id = arg1.parse()?;
|
|
let res = dc_get_msg_info(context, id);
|
|
println!("{}", as_str(res));
|
|
}
|
|
"listfresh" => {
|
|
let msglist = dc_get_fresh_msgs(context);
|
|
ensure!(!msglist.is_null(), "Failed to retrieve messages");
|
|
|
|
log_msglist(context, msglist);
|
|
print!("{} fresh messages.", dc_array_get_cnt(msglist));
|
|
dc_array_unref(msglist);
|
|
}
|
|
"forward" => {
|
|
ensure!(
|
|
!arg1.is_empty() && arg2.is_empty(),
|
|
"Arguments <msg-id> <chat-id> expected"
|
|
);
|
|
|
|
let mut msg_ids = [0; 1];
|
|
let chat_id = arg2.parse()?;
|
|
msg_ids[0] = arg1.parse()?;
|
|
dc_forward_msgs(context, msg_ids.as_mut_ptr(), 1, chat_id);
|
|
}
|
|
"markseen" => {
|
|
ensure!(!arg1.is_empty(), "Argument <msg-id> missing.");
|
|
let mut msg_ids = [0; 1];
|
|
msg_ids[0] = arg1.parse()?;
|
|
dc_markseen_msgs(context, msg_ids.as_mut_ptr(), 1);
|
|
}
|
|
"star" | "unstar" => {
|
|
ensure!(!arg1.is_empty(), "Argument <msg-id> missing.");
|
|
let mut msg_ids = [0; 1];
|
|
msg_ids[0] = arg1.parse()?;
|
|
dc_star_msgs(
|
|
context,
|
|
msg_ids.as_mut_ptr(),
|
|
1,
|
|
if arg0 == "star" { 1 } else { 0 },
|
|
);
|
|
}
|
|
"delmsg" => {
|
|
ensure!(!arg1.is_empty(), "Argument <msg-id> missing.");
|
|
let mut ids = [0; 1];
|
|
ids[0] = arg1.parse()?;
|
|
dc_delete_msgs(context, ids.as_mut_ptr(), 1);
|
|
}
|
|
"listcontacts" | "contacts" | "listverified" => {
|
|
let contacts = Contact::get_all(
|
|
context,
|
|
if arg0 == "listverified" {
|
|
0x1 | 0x2
|
|
} else {
|
|
0x2
|
|
},
|
|
Some(arg1),
|
|
)?;
|
|
if !contacts.is_null() {
|
|
log_contactlist(context, contacts);
|
|
println!("{} contacts.", dc_array_get_cnt(contacts) as libc::c_int,);
|
|
dc_array_unref(contacts);
|
|
} else {
|
|
bail!("");
|
|
}
|
|
}
|
|
"addcontact" => {
|
|
ensure!(!arg1.is_empty(), "Arguments [<name>] <addr> expected.");
|
|
|
|
if !arg2.is_empty() {
|
|
let book = format!("{}\n{}", arg1, arg2);
|
|
Contact::add_address_book(context, book)?;
|
|
} else {
|
|
Contact::create(context, "", arg1)?;
|
|
}
|
|
}
|
|
"contactinfo" => {
|
|
ensure!(!arg1.is_empty(), "Argument <contact-id> missing.");
|
|
|
|
let contact_id = arg1.parse()?;
|
|
let contact = Contact::get_by_id(context, contact_id)?;
|
|
let name_n_addr = contact.get_name_n_addr();
|
|
|
|
let mut res = format!("Contact info for: {}:\n\n", name_n_addr);
|
|
|
|
res += &Contact::get_encrinfo(context, contact_id)?;
|
|
|
|
let chatlist = Chatlist::try_load(context, 0, None, Some(contact_id))?;
|
|
let chatlist_cnt = chatlist.len();
|
|
if chatlist_cnt > 0 {
|
|
res += &format!(
|
|
"\n\n{} chats shared with Contact#{}: ",
|
|
chatlist_cnt, contact_id,
|
|
);
|
|
for i in 0..chatlist_cnt {
|
|
if 0 != i {
|
|
res += ", ";
|
|
}
|
|
let chat = dc_get_chat(context, chatlist.get_chat_id(i));
|
|
res += &format!("{}#{}", chat_prefix(chat), dc_chat_get_id(chat));
|
|
dc_chat_unref(chat);
|
|
}
|
|
}
|
|
|
|
println!("{}", res);
|
|
}
|
|
"delcontact" => {
|
|
ensure!(!arg1.is_empty(), "Argument <contact-id> missing.");
|
|
Contact::delete(context, arg1.parse()?)?;
|
|
}
|
|
"checkqr" => {
|
|
ensure!(!arg1.is_empty(), "Argument <qr-content> missing.");
|
|
let res = dc_check_qr(context, arg1_c);
|
|
println!(
|
|
"state={}, id={}, text1={}, text2={}",
|
|
(*res).state as libc::c_int,
|
|
(*res).id,
|
|
to_string((*res).text1),
|
|
to_string((*res).text2)
|
|
);
|
|
dc_lot_unref(res);
|
|
}
|
|
"event" => {
|
|
ensure!(!arg1.is_empty(), "Argument <id> missing.");
|
|
let event = arg1.parse()?;
|
|
let event = Event::from_u32(event).ok_or(format_err!("Event::from_u32({})", event))?;
|
|
let r = context.call_cb(event, 0 as uintptr_t, 0 as uintptr_t);
|
|
println!(
|
|
"Sending event {:?}({}), received value {}.",
|
|
event, event as usize, r as libc::c_int,
|
|
);
|
|
}
|
|
"fileinfo" => {
|
|
ensure!(!arg1.is_empty(), "Argument <file> missing.");
|
|
let mut buf = 0 as *mut libc::c_uchar;
|
|
let mut buf_bytes = 0;
|
|
let mut w = 0;
|
|
let mut h = 0;
|
|
|
|
if 0 != dc_read_file(
|
|
context,
|
|
arg1_c,
|
|
&mut buf as *mut *mut libc::c_uchar as *mut *mut libc::c_void,
|
|
&mut buf_bytes,
|
|
) {
|
|
dc_get_filemeta(buf as *const libc::c_void, buf_bytes, &mut w, &mut h);
|
|
println!("width={}, height={}", w, h,);
|
|
free(buf as *mut libc::c_void);
|
|
} else {
|
|
bail!("Command failed.");
|
|
}
|
|
}
|
|
"" => (),
|
|
_ => bail!("Unknown command: \"{}\" type ? for help.", arg0),
|
|
}
|
|
|
|
if !sel_chat.is_null() {
|
|
dc_chat_unref(sel_chat);
|
|
}
|
|
|
|
free(arg1_c as *mut _);
|
|
free(arg2_c as *mut _);
|
|
|
|
Ok(())
|
|
}
|