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

Remove the context reference from Message struct

Browse Source 
The Message struct had a reference to the context which made a few
APIs a little easier.  However it has surprising consequences a long
way down the line as shown in #335: it means any object which has such
a reference needs to keep open a lock if we want to do this refactor
of no longer having a "closed" Context struct on the Rust API (which
has many benefits which will simply that Context struct and is more
the Rust way - RAII etc).

By refactoring away the context reference on the rust API as done in
here however, we push this behaviour of how these references are
handled back to the C-API pointer behaviour: that is unsafe but just
works in a C-like way.  The resulting complexity in the FFI layer is
also notably less than in the #335 alternative.

As a consequence all APIs which require the context, now explicitly
need to get the context passed in as an argument.  It looks like this
is certainly no downside and maybe even beneficial for further API
refactors.

For this strategy to work out the same should be done to
dc_chatlist_t, dc_chat_t and dc_contact_t.  But this working for
dc_msg_t give a reasonable confidence that this is a good approach.
This commit is contained in:
Floris Bruynooghe
2019-09-09 21:35:08 +02:00
committed by Floris Bruynooghe
parent e73671a6ff
commit a0b5e32f98
9 changed files with 206 additions and 223 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -484,11 +484,9 @@ pub unsafe extern "C" fn dc_prepare_msg(
eprintln!("ignoring careless call to dc_prepare_msg()");
return 0;
}
let context = &mut *context;
let msg = &mut *msg;
chat::prepare_msg(context, chat_id, msg)
let ffi_msg: &mut MessageWrapper = &mut *msg;
chat::prepare_msg(context, chat_id, &mut ffi_msg.message)
.unwrap_or_log_default(context, "Failed to prepare message")
}
@@ -502,11 +500,10 @@ pub unsafe extern "C" fn dc_send_msg(
eprintln!("ignoring careless call to dc_send_msg()");
return 0;
}
let context = &mut *context;
let msg = &mut *msg;
chat::send_msg(context, chat_id, msg).unwrap_or_log_default(context, "Failed to send message")
let ffi_msg = &mut *msg;
chat::send_msg(context, chat_id, &mut ffi_msg.message)
.unwrap_or_log_default(context, "Failed to send message")
}
#[no_mangle]
@@ -537,26 +534,32 @@ pub unsafe extern "C" fn dc_set_draft(
eprintln!("ignoring careless call to dc_set_draft()");
return;
}
let context = &*context;
let msg = if msg.is_null() { None } else { Some(&mut *msg) };
let msg = if msg.is_null() {
None
} else {
let ffi_msg: &mut MessageWrapper = &mut *msg;
Some(&mut ffi_msg.message)
};
chat::set_draft(context, chat_id, msg)
}
#[no_mangle]
pub unsafe extern "C" fn dc_get_draft<'a>(
context: *mut dc_context_t,
chat_id: u32,
) -> *mut dc_msg_t<'a> {
pub unsafe extern "C" fn dc_get_draft(context: *mut dc_context_t, chat_id: u32) -> *mut dc_msg_t {
if context.is_null() {
eprintln!("ignoring careless call to dc_get_draft()");
return ptr::null_mut(); // NULL explicitly defined as "no draft"
}
let context = &*context;
chat::get_draft(context, chat_id).into_raw()
let message = match chat::get_draft(context, chat_id) {
Ok(msg) => msg,
Err(e) => {
error!(context, "Failed to get draft for chat #{}: {}", chat_id, e);
return ptr::null_mut();
}
};
let ffi_msg = MessageWrapper { context, message };
Box::into_raw(Box::new(ffi_msg))
}
#[no_mangle]
@@ -1022,18 +1025,21 @@ pub unsafe extern "C" fn dc_star_msgs(
}
#[no_mangle]
pub unsafe extern "C" fn dc_get_msg<'a>(
context: *mut dc_context_t,
msg_id: u32,
) -> *mut dc_msg_t<'a> {
pub unsafe extern "C" fn dc_get_msg(context: *mut dc_context_t, msg_id: u32) -> *mut dc_msg_t {
if context.is_null() {
eprintln!("ignoring careless call to dc_get_msg()");
return ptr::null_mut();
}
let context = &*context;
message::dc_get_msg(context, msg_id).into_raw()
let message = match message::dc_get_msg(context, msg_id) {
Ok(msg) => msg,
Err(e) => {
error!(context, "Error getting msg #{}: {}", msg_id, e);
return ptr::null_mut();
}
};
let ffi_msg = MessageWrapper { context, message };
Box::into_raw(Box::new(ffi_msg))
}
#[no_mangle]
@@ -1865,23 +1871,37 @@ pub unsafe extern "C" fn dc_chat_is_sending_locations(chat: *mut dc_chat_t) -> l
// dc_msg_t
#[no_mangle]
pub type dc_msg_t<'a> = message::Message<'a>;
/// FFI struct for [dc_msg_t]
///
/// This is the structure behind [dc_msg_t] which is the opaque
/// structure representing a message in the FFI API. It exists
/// because the FFI API has a refernce from the message to the
/// context, but the Rust API does not, so the FFI layer needs to glue
/// these together.
pub struct MessageWrapper {
context: *const dc_context_t,
message: message::Message,
}
#[no_mangle]
pub unsafe extern "C" fn dc_msg_new<'a>(
pub type dc_msg_t = MessageWrapper;
#[no_mangle]
pub unsafe extern "C" fn dc_msg_new(
context: *mut dc_context_t,
viewtype: libc::c_int,
) -> *mut dc_msg_t<'a> {
) -> *mut dc_msg_t {
if context.is_null() {
eprintln!("ignoring careless call to dc_msg_new()");
return ptr::null_mut();
}
let context = &*context;
let viewtype = from_prim(viewtype).expect(&format!("invalid viewtype = {}", viewtype));
Box::into_raw(Box::new(message::dc_msg_new(context, viewtype)))
let msg = MessageWrapper {
context,
message: message::dc_msg_new(viewtype),
};
Box::into_raw(Box::new(msg))
}
#[no_mangle]
@@ -1900,9 +1920,8 @@ pub unsafe extern "C" fn dc_msg_get_id(msg: *mut dc_msg_t) -> u32 {
eprintln!("ignoring careless call to dc_msg_get_id()");
return 0;
}
let msg = &*msg;
message::dc_msg_get_id(msg)
let ffi_msg = &*msg;
message::dc_msg_get_id(&ffi_msg.message)
}
#[no_mangle]
@@ -1911,9 +1930,8 @@ pub unsafe extern "C" fn dc_msg_get_from_id(msg: *mut dc_msg_t) -> u32 {
eprintln!("ignoring careless call to dc_msg_get_from_id()");
return 0;
}
let msg = &*msg;
message::dc_msg_get_from_id(msg)
let ffi_msg = &*msg;
message::dc_msg_get_from_id(&ffi_msg.message)
}
#[no_mangle]
@@ -1922,9 +1940,8 @@ pub unsafe extern "C" fn dc_msg_get_chat_id(msg: *mut dc_msg_t) -> u32 {
eprintln!("ignoring careless call to dc_msg_get_chat_id()");
return 0;
}
let msg = &*msg;
message::dc_msg_get_chat_id(msg)
let ffi_msg = &*msg;
message::dc_msg_get_chat_id(&ffi_msg.message)
}
#[no_mangle]
@@ -1933,9 +1950,8 @@ pub unsafe extern "C" fn dc_msg_get_viewtype(msg: *mut dc_msg_t) -> libc::c_int
eprintln!("ignoring careless call to dc_msg_get_viewtype()");
return 0;
}
let msg = &*msg;
message::dc_msg_get_viewtype(msg)
let ffi_msg = &*msg;
message::dc_msg_get_viewtype(&ffi_msg.message)
.to_i64()
.expect("impossible: Viewtype -> i64 conversion failed") as libc::c_int
}
@@ -1946,9 +1962,8 @@ pub unsafe extern "C" fn dc_msg_get_state(msg: *mut dc_msg_t) -> libc::c_int {
eprintln!("ignoring careless call to dc_msg_get_state()");
return 0;
}
let msg = &*msg;
message::dc_msg_get_state(msg) as libc::c_int
let ffi_msg = &*msg;
message::dc_msg_get_state(&ffi_msg.message) as libc::c_int
}
#[no_mangle]
@@ -1957,9 +1972,8 @@ pub unsafe extern "C" fn dc_msg_get_timestamp(msg: *mut dc_msg_t) -> i64 {
eprintln!("ignoring careless call to dc_msg_get_received_timestamp()");
return 0;
}
let msg = &*msg;
message::dc_msg_get_timestamp(msg)
let ffi_msg = &*msg;
message::dc_msg_get_timestamp(&ffi_msg.message)
}
#[no_mangle]
@@ -1968,9 +1982,8 @@ pub unsafe extern "C" fn dc_msg_get_received_timestamp(msg: *mut dc_msg_t) -> i6
eprintln!("ignoring careless call to dc_msg_get_received_timestamp()");
return 0;
}
let msg = &*msg;
message::dc_msg_get_received_timestamp(msg)
let ffi_msg = &*msg;
message::dc_msg_get_received_timestamp(&ffi_msg.message)
}
#[no_mangle]
@@ -1979,9 +1992,8 @@ pub unsafe extern "C" fn dc_msg_get_sort_timestamp(msg: *mut dc_msg_t) -> i64 {
eprintln!("ignoring careless call to dc_msg_get_sort_timestamp()");
return 0;
}
let msg = &*msg;
message::dc_msg_get_sort_timestamp(msg)
let ffi_msg = &*msg;
message::dc_msg_get_sort_timestamp(&ffi_msg.message)
}
#[no_mangle]
@@ -1990,9 +2002,8 @@ pub unsafe extern "C" fn dc_msg_get_text(msg: *mut dc_msg_t) -> *mut libc::c_cha
eprintln!("ignoring careless call to dc_msg_get_text()");
return dc_strdup(ptr::null());
}
let msg = &*msg;
message::dc_msg_get_text(msg)
let ffi_msg = &*msg;
message::dc_msg_get_text(&ffi_msg.message)
}
#[no_mangle]
@@ -2001,9 +2012,8 @@ pub unsafe extern "C" fn dc_msg_get_file(msg: *mut dc_msg_t) -> *mut libc::c_cha
eprintln!("ignoring careless call to dc_msg_get_file()");
return dc_strdup(ptr::null());
}
let msg = &*msg;
message::dc_msg_get_file(msg)
let ffi_msg = &*msg;
message::dc_msg_get_file(&*ffi_msg.context, &ffi_msg.message)
}
#[no_mangle]
@@ -2012,9 +2022,8 @@ pub unsafe extern "C" fn dc_msg_get_filename(msg: *mut dc_msg_t) -> *mut libc::c
eprintln!("ignoring careless call to dc_msg_get_filename()");
return dc_strdup(ptr::null());
}
let msg = &*msg;
message::dc_msg_get_filename(msg)
let ffi_msg = &*msg;
message::dc_msg_get_filename(&ffi_msg.message)
}
#[no_mangle]
@@ -2023,9 +2032,8 @@ pub unsafe extern "C" fn dc_msg_get_filemime(msg: *mut dc_msg_t) -> *mut libc::c
eprintln!("ignoring careless call to dc_msg_get_filemime()");
return dc_strdup(ptr::null());
}
let msg = &*msg;
message::dc_msg_get_filemime(msg).strdup()
let ffi_msg = &*msg;
message::dc_msg_get_filemime(&ffi_msg.message).strdup()
}
#[no_mangle]
@@ -2034,9 +2042,8 @@ pub unsafe extern "C" fn dc_msg_get_filebytes(msg: *mut dc_msg_t) -> u64 {
eprintln!("ignoring careless call to dc_msg_get_filebytes()");
return 0;
}
let msg = &*msg;
message::dc_msg_get_filebytes(msg)
let ffi_msg = &*msg;
message::dc_msg_get_filebytes(&*ffi_msg.context, &ffi_msg.message)
}
#[no_mangle]
@@ -2045,9 +2052,8 @@ pub unsafe extern "C" fn dc_msg_get_width(msg: *mut dc_msg_t) -> libc::c_int {
eprintln!("ignoring careless call to dc_msg_get_width()");
return 0;
}
let msg = &*msg;
message::dc_msg_get_width(msg)
let ffi_msg = &*msg;
message::dc_msg_get_width(&ffi_msg.message)
}
#[no_mangle]
@@ -2056,9 +2062,8 @@ pub unsafe extern "C" fn dc_msg_get_height(msg: *mut dc_msg_t) -> libc::c_int {
eprintln!("ignoring careless call to dc_msg_get_height()");
return 0;
}
let msg = &*msg;
message::dc_msg_get_height(msg)
let ffi_msg = &*msg;
message::dc_msg_get_height(&ffi_msg.message)
}
#[no_mangle]
@@ -2067,9 +2072,8 @@ pub unsafe extern "C" fn dc_msg_get_duration(msg: *mut dc_msg_t) -> libc::c_int
eprintln!("ignoring careless call to dc_msg_get_duration()");
return 0;
}
let msg = &*msg;
message::dc_msg_get_duration(msg)
let ffi_msg = &*msg;
message::dc_msg_get_duration(&ffi_msg.message)
}
#[no_mangle]
@@ -2078,25 +2082,22 @@ pub unsafe extern "C" fn dc_msg_get_showpadlock(msg: *mut dc_msg_t) -> libc::c_i
eprintln!("ignoring careless call to dc_msg_get_showpadlock()");
return 0;
}
let msg = &*msg;
message::dc_msg_get_showpadlock(msg)
let ffi_msg = &*msg;
message::dc_msg_get_showpadlock(&ffi_msg.message)
}
#[no_mangle]
pub unsafe extern "C" fn dc_msg_get_summary<'a>(
msg: *mut dc_msg_t<'a>,
chat: *mut dc_chat_t<'a>,
pub unsafe extern "C" fn dc_msg_get_summary(
msg: *mut dc_msg_t,
chat: *mut dc_chat_t,
) -> *mut dc_lot_t {
if msg.is_null() {
eprintln!("ignoring careless call to dc_msg_get_summary()");
return ptr::null_mut();
}
let chat = if chat.is_null() { None } else { Some(&*chat) };
let msg = &mut *msg;
let lot = message::dc_msg_get_summary(msg, chat);
let ffi_msg = &mut *msg;
let lot = message::dc_msg_get_summary(&*ffi_msg.context, &mut ffi_msg.message, chat);
Box::into_raw(Box::new(lot))
}
@@ -2109,9 +2110,12 @@ pub unsafe extern "C" fn dc_msg_get_summarytext(
eprintln!("ignoring careless call to dc_msg_get_summarytext()");
return dc_strdup(ptr::null());
}
let msg = &mut *msg;
message::dc_msg_get_summarytext(msg, approx_characters.try_into().unwrap())
let ffi_msg = &mut *msg;
message::dc_msg_get_summarytext(
&*ffi_msg.context,
&mut ffi_msg.message,
approx_characters.try_into().unwrap(),
)
}
#[no_mangle]
@@ -2120,9 +2124,8 @@ pub unsafe extern "C" fn dc_msg_has_deviating_timestamp(msg: *mut dc_msg_t) -> l
eprintln!("ignoring careless call to dc_msg_has_deviating_timestamp()");
return 0;
}
let msg = &*msg;
message::dc_msg_has_deviating_timestamp(msg)
let ffi_msg = &*msg;
message::dc_msg_has_deviating_timestamp(&ffi_msg.message)
}
#[no_mangle]
@@ -2131,9 +2134,8 @@ pub unsafe extern "C" fn dc_msg_has_location(msg: *mut dc_msg_t) -> libc::c_int
eprintln!("ignoring careless call to dc_msg_has_location()");
return 0;
}
let msg = &*msg;
message::dc_msg_has_location(msg) as libc::c_int
let ffi_msg = &*msg;
message::dc_msg_has_location(&ffi_msg.message) as libc::c_int
}
#[no_mangle]
@@ -2142,9 +2144,8 @@ pub unsafe extern "C" fn dc_msg_is_sent(msg: *mut dc_msg_t) -> libc::c_int {
eprintln!("ignoring careless call to dc_msg_is_sent()");
return 0;
}
let msg = &*msg;
message::dc_msg_is_sent(msg)
let ffi_msg = &*msg;
message::dc_msg_is_sent(&ffi_msg.message)
}
#[no_mangle]
@@ -2153,9 +2154,8 @@ pub unsafe extern "C" fn dc_msg_is_starred(msg: *mut dc_msg_t) -> libc::c_int {
eprintln!("ignoring careless call to dc_msg_is_starred()");
return 0;
}
let msg = &*msg;
message::dc_msg_is_starred(msg).into()
let ffi_msg = &*msg;
message::dc_msg_is_starred(&ffi_msg.message).into()
}
#[no_mangle]
@@ -2164,9 +2164,8 @@ pub unsafe extern "C" fn dc_msg_is_forwarded(msg: *mut dc_msg_t) -> libc::c_int
eprintln!("ignoring careless call to dc_msg_is_forwarded()");
return 0;
}
let msg = &*msg;
message::dc_msg_is_forwarded(msg)
let ffi_msg = &*msg;
message::dc_msg_is_forwarded(&ffi_msg.message)
}
#[no_mangle]
@@ -2175,9 +2174,8 @@ pub unsafe extern "C" fn dc_msg_is_info(msg: *mut dc_msg_t) -> libc::c_int {
eprintln!("ignoring careless call to dc_msg_is_info()");
return 0;
}
let msg = &*msg;
message::dc_msg_is_info(msg)
let ffi_msg = &*msg;
message::dc_msg_is_info(&ffi_msg.message)
}
#[no_mangle]
@@ -2186,9 +2184,8 @@ pub unsafe extern "C" fn dc_msg_is_increation(msg: *mut dc_msg_t) -> libc::c_int
eprintln!("ignoring careless call to dc_msg_is_increation()");
return 0;
}
let msg = &*msg;
message::dc_msg_is_increation(msg)
let ffi_msg = &*msg;
message::dc_msg_is_increation(&ffi_msg.message)
}
#[no_mangle]
@@ -2197,9 +2194,8 @@ pub unsafe extern "C" fn dc_msg_is_setupmessage(msg: *mut dc_msg_t) -> libc::c_i
eprintln!("ignoring careless call to dc_msg_is_setupmessage()");
return 0;
}
let msg = &*msg;
message::dc_msg_is_setupmessage(msg) as libc::c_int
let ffi_msg = &*msg;
message::dc_msg_is_setupmessage(&ffi_msg.message) as libc::c_int
}
#[no_mangle]
@@ -2208,9 +2204,8 @@ pub unsafe extern "C" fn dc_msg_get_setupcodebegin(msg: *mut dc_msg_t) -> *mut l
eprintln!("ignoring careless call to dc_msg_get_setupcodebegin()");
return dc_strdup(ptr::null());
}
let msg = &*msg;
message::dc_msg_get_setupcodebegin(msg)
let ffi_msg = &*msg;
message::dc_msg_get_setupcodebegin(&*ffi_msg.context, &ffi_msg.message)
}
#[no_mangle]
@@ -2219,10 +2214,9 @@ pub unsafe extern "C" fn dc_msg_set_text(msg: *mut dc_msg_t, text: *mut libc::c_
eprintln!("ignoring careless call to dc_msg_set_text()");
return;
}
let msg = &mut *msg;
let ffi_msg = &mut *msg;
// TODO: {text} equal to NULL is treated as "", which is strange. Does anyone rely on it?
message::dc_msg_set_text(msg, text)
message::dc_msg_set_text(&mut ffi_msg.message, text)
}
#[no_mangle]
@@ -2235,9 +2229,8 @@ pub unsafe extern "C" fn dc_msg_set_file(
eprintln!("ignoring careless call to dc_msg_set_file()");
return;
}
let msg = &mut *msg;
message::dc_msg_set_file(msg, file, filemime)
let ffi_msg = &mut *msg;
message::dc_msg_set_file(&mut ffi_msg.message, file, filemime)
}
#[no_mangle]
@@ -2250,9 +2243,8 @@ pub unsafe extern "C" fn dc_msg_set_dimension(
eprintln!("ignoring careless call to dc_msg_set_dimension()");
return;
}
let msg = &mut *msg;
message::dc_msg_set_dimension(msg, width, height)
let ffi_msg = &mut *msg;
message::dc_msg_set_dimension(&mut ffi_msg.message, width, height)
}
#[no_mangle]
@@ -2261,9 +2253,8 @@ pub unsafe extern "C" fn dc_msg_set_duration(msg: *mut dc_msg_t, duration: libc:
eprintln!("ignoring careless call to dc_msg_set_duration()");
return;
}
let msg = &mut *msg;
message::dc_msg_set_duration(msg, duration)
let ffi_msg = &mut *msg;
message::dc_msg_set_duration(&mut ffi_msg.message, duration)
}
#[no_mangle]
@@ -2276,9 +2267,8 @@ pub unsafe extern "C" fn dc_msg_set_location(
eprintln!("ignoring careless call to dc_msg_set_location()");
return;
}
let msg = &mut *msg;
message::dc_msg_set_location(msg, latitude, longitude)
let ffi_msg = &mut *msg;
message::dc_msg_set_location(&mut ffi_msg.message, latitude, longitude)
}
#[no_mangle]
@@ -2292,9 +2282,14 @@ pub unsafe extern "C" fn dc_msg_latefiling_mediasize(
eprintln!("ignoring careless call to dc_msg_latefiling_mediasize()");
return;
}
let msg = &mut *msg;
message::dc_msg_latefiling_mediasize(msg, width, height, duration)
let ffi_msg = &mut *msg;
message::dc_msg_latefiling_mediasize(
&*ffi_msg.context,
&mut ffi_msg.message,
width,
height,
duration,
)
}
// dc_contact_t

17
examples/repl/cmdline.rs
View File

@@ -476,7 +476,7 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
let msg_id: u32 = arg1.parse()?;
let msg = dc_get_msg(context, msg_id)?;
if dc_msg_is_setupmessage(&msg) {
let setupcodebegin = dc_msg_get_setupcodebegin(&msg);
let setupcodebegin = dc_msg_get_setupcodebegin(context, &msg);
println!(
"The setup code for setup message Msg#{} starts with: {}",
msg_id,
@@ -836,14 +836,11 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
ensure!(sel_chat.is_some(), "No chat selected.");
ensure!(!arg1.is_empty(), "No file given.");
let mut msg = dc_msg_new(
context,
if arg0 == "sendimage" {
Viewtype::Image
} else {
Viewtype::File
},
);
let mut msg = dc_msg_new(if arg0 == "sendimage" {
Viewtype::Image
} else {
Viewtype::File
});
dc_msg_set_file(&mut msg, arg1_c, ptr::null());
if !arg2.is_empty() {
dc_msg_set_text(&mut msg, arg2_c);
@@ -868,7 +865,7 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
ensure!(sel_chat.is_some(), "No chat selected.");
if !arg1.is_empty() {
let mut draft = dc_msg_new(context, Viewtype::Text);
let mut draft = dc_msg_new(Viewtype::Text);
dc_msg_set_text(&mut draft, arg1_c);
chat::set_draft(
context,

31
src/chat.rs
View File

@@ -635,7 +635,7 @@ pub fn get_by_contact_id(context: &Context, contact_id: u32) -> Result<u32, Erro
pub fn prepare_msg<'a>(
context: &'a Context,
chat_id: u32,
msg: &mut Message<'a>,
msg: &mut Message,
) -> Result<u32, Error> {
ensure!(
chat_id > DC_CHAT_ID_LAST_SPECIAL,
@@ -665,13 +665,8 @@ pub fn msgtype_has_file(msgtype: Viewtype) -> bool {
}
}
fn prepare_msg_common<'a>(
context: &'a Context,
chat_id: u32,
msg: &mut Message<'a>,
) -> Result<u32, Error> {
fn prepare_msg_common(context: &Context, chat_id: u32, msg: &mut Message) -> Result<u32, Error> {
msg.id = 0;
msg.context = context;
if msg.type_0 == Viewtype::Text {
// the caller should check if the message text is empty
@@ -787,11 +782,7 @@ pub fn unarchive(context: &Context, chat_id: u32) -> Result<(), Error> {
/// However, this does not imply, the message really reached the recipient -
/// sending may be delayed eg. due to network problems. However, from your
/// view, you're done with the message. Sooner or later it will find its way.
pub fn send_msg<'a>(
context: &'a Context,
chat_id: u32,
msg: &mut Message<'a>,
) -> Result<u32, Error> {
pub fn send_msg(context: &Context, chat_id: u32, msg: &mut Message) -> Result<u32, Error> {
if msg.state != MessageState::OutPreparing {
// automatically prepare normal messages
prepare_msg_common(context, chat_id, msg)?;
@@ -835,7 +826,7 @@ pub fn send_msg<'a>(
}
}
msg.param.remove(Param::PrepForwards);
dc_msg_save_param_to_disk(msg);
dc_msg_save_param_to_disk(context, msg);
}
}
@@ -853,7 +844,7 @@ pub unsafe fn send_text_msg(
chat_id
);
let mut msg = dc_msg_new(context, Viewtype::Text);
let mut msg = dc_msg_new(Viewtype::Text);
msg.text = Some(text_to_send);
send_msg(context, chat_id, &mut msg)
}
@@ -1295,7 +1286,7 @@ pub unsafe fn create_group_chat(
if chat_id != 0 {
if 0 != add_to_chat_contacts_table(context, chat_id, 1) {
let mut draft_msg = dc_msg_new(context, Viewtype::Text);
let mut draft_msg = dc_msg_new(Viewtype::Text);
dc_msg_set_text(&mut draft_msg, draft_txt.as_ptr());
set_draft_raw(context, chat_id, Some(&mut draft_msg));
}
@@ -1340,7 +1331,7 @@ pub fn add_contact_to_chat_ex(
if contact.is_err() || chat_id <= DC_CHAT_ID_LAST_SPECIAL {
return 0;
}
let mut msg = unsafe { dc_msg_new_untyped(context) };
let mut msg = dc_msg_new_untyped();
reset_gossiped_timestamp(context, chat_id);
let contact = contact.unwrap();
@@ -1489,7 +1480,7 @@ pub unsafe fn remove_contact_from_chat(
"Cannot remove special contact"
);
let mut msg = dc_msg_new_untyped(context);
let mut msg = dc_msg_new_untyped();
let mut success = false;
/* we do not check if "contact_id" exists but just delete all records with the id from chats_contacts */
@@ -1588,7 +1579,7 @@ pub unsafe fn set_chat_name(
ensure!(chat_id > DC_CHAT_ID_LAST_SPECIAL, "Invalid chat ID");
let chat = Chat::load_from_db(context, chat_id)?;
let mut msg = dc_msg_new_untyped(context);
let mut msg = dc_msg_new_untyped();
if real_group_exists(context, chat_id) {
if &chat.name == new_name.as_ref() {
@@ -1684,7 +1675,7 @@ pub fn set_chat_profile_image(
chat.param.set(Param::ProfileImage, &new_image_rel);
if chat.update_param().is_ok() {
if chat.is_promoted() {
let mut msg = unsafe { dc_msg_new_untyped(context) };
let mut msg = dc_msg_new_untyped();
msg.param.set_int(Param::Cmd, DC_CMD_GROUPIMAGE_CHANGED);
msg.type_0 = Viewtype::Text;
msg.text = Some(context.stock_system_msg(
@@ -1779,7 +1770,7 @@ pub unsafe fn forward_msgs(
msg.param.set(Param::PrepForwards, new_msg_id.to_string());
}
dc_msg_save_param_to_disk(&mut msg);
dc_msg_save_param_to_disk(context, &mut msg);
msg.param = save_param;
} else {
msg.state = MessageState::OutPending;

4
src/dc_imex.rs
View File

@@ -138,7 +138,7 @@ pub unsafe fn dc_initiate_key_transfer(context: &Context) -> *mut libc::c_char {
))
{
if let Ok(chat_id) = chat::create_by_contact_id(context, 1) {
msg = dc_msg_new_untyped(context);
msg = dc_msg_new_untyped();
msg.type_0 = Viewtype::File;
msg.param.set(Param::File, as_str(setup_file_name));
@@ -281,7 +281,7 @@ pub unsafe fn dc_continue_key_transfer(
if msg.is_err()
|| !dc_msg_is_setupmessage(msg.as_ref().unwrap())
|| {
filename = dc_msg_get_file(msg.as_ref().unwrap());
filename = dc_msg_get_file(context, msg.as_ref().unwrap());
filename.is_null()
}
|| *filename.offset(0isize) as libc::c_int == 0i32

34
src/dc_mimefactory.rs
View File

@@ -37,7 +37,7 @@ pub struct dc_mimefactory_t<'a> {
pub timestamp: i64,
pub rfc724_mid: *mut libc::c_char,
pub loaded: dc_mimefactory_loaded_t,
pub msg: Message<'a>,
pub msg: Message,
pub chat: Option<Chat<'a>>,
pub increation: libc::c_int,
pub in_reply_to: *mut libc::c_char,
@@ -335,7 +335,10 @@ pub unsafe fn dc_mimefactory_load_mdn<'a>(
}
// TODO should return bool /rtn
pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_int {
pub unsafe fn dc_mimefactory_render(
context: &Context,
factory: &mut dc_mimefactory_t,
) -> libc::c_int {
let subject: *mut mailimf_subject;
let mut ok_to_continue = true;
let imf_fields: *mut mailimf_fields;
@@ -586,7 +589,7 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
}
if 0 != msg.param.get_int(Param::Arg2).unwrap_or_default() & 0x1 {
info!(
msg.context,
context,
"sending secure-join message \'{}\' >>>>>>>>>>>>>>>>>>>>>>>>>",
"vg-member-added",
);
@@ -654,7 +657,7 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
let step = msg.param.get(Param::Arg).unwrap_or_default().strdup();
if strlen(step) > 0 {
info!(
msg.context,
context,
"sending secure-join message \'{}\' >>>>>>>>>>>>>>>>>>>>>>>>>",
as_str(step),
);
@@ -725,12 +728,13 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
}
if let Some(grpimage) = grpimage {
info!(factory.context, "setting group image '{}'", grpimage);
let mut meta = dc_msg_new_untyped(factory.context);
let mut meta = dc_msg_new_untyped();
meta.type_0 = Viewtype::Image;
meta.param.set(Param::File, grpimage);
let mut filename_as_sent = ptr::null_mut();
meta_part = build_body_file(
context,
&meta,
b"group-image\x00" as *const u8 as *const libc::c_char,
&mut filename_as_sent,
@@ -833,7 +837,7 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
/* add attachment part */
if chat::msgtype_has_file(factory.msg.type_0) {
if !is_file_size_okay(&factory.msg) {
if !is_file_size_okay(context, &factory.msg) {
let error: *mut libc::c_char = dc_mprintf(
b"Message exceeds the recommended %i MB.\x00" as *const u8
as *const libc::c_char,
@@ -844,7 +848,7 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
ok_to_continue = false;
} else {
let file_part: *mut mailmime =
build_body_file(&factory.msg, ptr::null(), ptr::null_mut());
build_body_file(context, &factory.msg, ptr::null(), ptr::null_mut());
if !file_part.is_null() {
mailmime_smart_add_part(message, file_part);
parts += 1
@@ -892,12 +896,9 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
mailmime_smart_add_part(message, kml_mime_part);
}
if location::is_sending_locations_to_chat(
factory.msg.context,
factory.msg.chat_id,
) {
if location::is_sending_locations_to_chat(context, factory.msg.chat_id) {
if let Ok((kml_file, last_added_location_id)) =
location::get_kml(factory.msg.context, factory.msg.chat_id)
location::get_kml(context, factory.msg.chat_id)
{
let content_type = mailmime_content_new_with_str(
b"application/vnd.google-earth.kml+xml\x00" as *const u8
@@ -950,7 +951,7 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
.stock_str(StockMessage::EncryptedMsg)
.into_owned()
} else {
to_string(dc_msg_get_summarytext(&mut factory.msg, 32))
to_string(dc_msg_get_summarytext(context, &mut factory.msg, 32))
};
let p2 = factory
.context
@@ -1134,6 +1135,7 @@ unsafe fn build_body_text(text: *mut libc::c_char) -> *mut mailmime {
#[allow(non_snake_case)]
unsafe fn build_body_file(
context: &Context,
msg: &Message,
mut base_name: *const libc::c_char,
ret_file_name_as_sent: *mut *mut libc::c_char,
@@ -1286,7 +1288,7 @@ unsafe fn build_body_file(
) as *mut libc::c_void,
);
mime_sub = mailmime_new_empty(content, mime_fields);
mailmime_set_body_file(mime_sub, dc_get_abs_path(msg.context, path_filename));
mailmime_set_body_file(mime_sub, dc_get_abs_path(context, path_filename));
if !ret_file_name_as_sent.is_null() {
*ret_file_name_as_sent = dc_strdup(filename_to_send)
}
@@ -1303,10 +1305,10 @@ unsafe fn build_body_file(
/*******************************************************************************
* Render
******************************************************************************/
unsafe fn is_file_size_okay(msg: &Message) -> bool {
unsafe fn is_file_size_okay(context: &Context, msg: &Message) -> bool {
let mut file_size_okay = true;
let path = msg.param.get(Param::File).unwrap_or_default();
let bytes = dc_get_filebytes(msg.context, &path);
let bytes = dc_get_filebytes(context, &path);
if bytes > (49 * 1024 * 1024 / 4 * 3) {
file_size_okay = false;

8
src/job.rs
View File

@@ -677,12 +677,12 @@ pub unsafe fn job_send_msg(context: &Context, msg_id: uint32_t) -> libc::c_int {
mimefactory.msg.param.set_int(Param::Height, height as i32);
}
}
dc_msg_save_param_to_disk(&mut mimefactory.msg);
dc_msg_save_param_to_disk(context, &mut mimefactory.msg);
}
}
}
/* create message */
if 0 == dc_mimefactory_render(&mut mimefactory) {
if 0 == dc_mimefactory_render(context, &mut mimefactory) {
dc_set_msg_failed(context, msg_id, as_opt_str(mimefactory.error));
} else if 0
!= mimefactory
@@ -745,7 +745,7 @@ pub unsafe fn job_send_msg(context: &Context, msg_id: uint32_t) -> libc::c_int {
== 0
{
mimefactory.msg.param.set_int(Param::GuranteeE2ee, 1);
dc_msg_save_param_to_disk(&mut mimefactory.msg);
dc_msg_save_param_to_disk(context, &mut mimefactory.msg);
}
success = add_smtp_job(context, Action::SendMsgToSmtp, &mut mimefactory);
}
@@ -992,7 +992,7 @@ fn connect_to_inbox(context: &Context, inbox: &Imap) -> libc::c_int {
fn send_mdn(context: &Context, msg_id: uint32_t) {
if let Ok(mut mimefactory) = unsafe { dc_mimefactory_load_mdn(context, msg_id) } {
if 0 != unsafe { dc_mimefactory_render(&mut mimefactory) } {
if 0 != unsafe { dc_mimefactory_render(context, &mut mimefactory) } {
add_smtp_job(context, Action::SendMdn, &mut mimefactory);
}
}

4
src/location.rs
View File

@@ -215,7 +215,7 @@ pub fn send_locations_to_chat(context: &Context, chat_id: u32, seconds: i64) {
.is_ok()
{
if 0 != seconds && !is_sending_locations_before {
msg = dc_msg_new(context, Viewtype::Text);
msg = dc_msg_new(Viewtype::Text);
msg.text =
Some(context.stock_system_msg(StockMessage::MsgLocationEnabled, "", "", 0));
msg.param.set_int(Param::Cmd, 8);
@@ -606,7 +606,7 @@ pub fn job_do_DC_JOB_MAYBE_SEND_LOCATIONS(context: &Context, _job: &Job) {
// the easiest way to determine this, is to check for an empty message queue.
// (might not be 100%, however, as positions are sent combined later
// and dc_set_location() is typically called periodically, this is ok)
let mut msg = dc_msg_new(context, Viewtype::Text);
let mut msg = dc_msg_new(Viewtype::Text);
msg.hidden = true;
msg.param.set_int(Param::Cmd, 9);
Some((chat_id, msg))

58
src/message.rs
View File

@@ -137,7 +137,7 @@ impl Lot {
/// approx. max. length returned by dc_msg_get_text()
/// approx. max. length returned by dc_get_msg_info()
#[derive(Clone)]
pub struct Message<'a> {
pub struct Message {
pub id: u32,
pub from_id: u32,
pub to_id: u32,
@@ -150,7 +150,6 @@ pub struct Message<'a> {
pub timestamp_sent: i64,
pub timestamp_rcvd: i64,
pub text: Option<String>,
pub context: &'a Context,
pub rfc724_mid: *mut libc::c_char,
pub in_reply_to: *mut libc::c_char,
pub server_folder: Option<String>,
@@ -270,7 +269,7 @@ pub unsafe fn dc_get_msg_info(context: &Context, msg_id: u32) -> *mut libc::c_ch
_ => {}
}
let p = dc_msg_get_file(&msg);
let p = dc_msg_get_file(context, &msg);
if !p.is_null() && 0 != *p.offset(0isize) as libc::c_int {
ret += &format!(
"\nFile: {}, {}, bytes\n",
@@ -310,11 +309,11 @@ pub unsafe fn dc_get_msg_info(context: &Context, msg_id: u32) -> *mut libc::c_ch
ret.strdup()
}
pub unsafe fn dc_msg_new_untyped<'a>(context: &'a Context) -> Message<'a> {
dc_msg_new(context, Viewtype::Unknown)
pub fn dc_msg_new_untyped() -> Message {
dc_msg_new(Viewtype::Unknown)
}
pub fn dc_msg_new<'a>(context: &'a Context, viewtype: Viewtype) -> Message<'a> {
pub fn dc_msg_new(viewtype: Viewtype) -> Message {
Message {
id: 0,
from_id: 0,
@@ -328,7 +327,6 @@ pub fn dc_msg_new<'a>(context: &'a Context, viewtype: Viewtype) -> Message<'a> {
timestamp_sent: 0,
timestamp_rcvd: 0,
text: None,
context,
rfc724_mid: std::ptr::null_mut(),
in_reply_to: std::ptr::null_mut(),
server_folder: None,
@@ -341,7 +339,7 @@ pub fn dc_msg_new<'a>(context: &'a Context, viewtype: Viewtype) -> Message<'a> {
}
}
impl<'a> Drop for Message<'a> {
impl Drop for Message {
fn drop(&mut self) {
unsafe {
free(self.rfc724_mid.cast());
@@ -380,11 +378,11 @@ pub fn dc_msg_guess_msgtype_from_suffix(path: &Path) -> Option<(Viewtype, &str)>
KNOWN.get(extension).map(|x| *x)
}
pub unsafe fn dc_msg_get_file(msg: &Message) -> *mut libc::c_char {
pub unsafe fn dc_msg_get_file(context: &Context, msg: &Message) -> *mut libc::c_char {
let mut file_abs = ptr::null_mut();
if let Some(file_rel) = msg.param.get(Param::File) {
file_abs = dc_get_abs_path(msg.context, file_rel);
file_abs = dc_get_abs_path(context, file_rel);
}
if !file_abs.is_null() {
file_abs
@@ -440,7 +438,7 @@ pub fn dc_msg_get_timestamp(msg: &Message) -> i64 {
}
}
pub fn dc_msg_load_from_db<'a>(context: &'a Context, id: u32) -> Result<Message<'a>, Error> {
pub fn dc_msg_load_from_db(context: &Context, id: u32) -> Result<Message, Error> {
context.sql.query_row(
"SELECT \
m.id,rfc724_mid,m.mime_in_reply_to,m.server_folder,m.server_uid,m.move_state,m.chat_id, \
@@ -451,8 +449,7 @@ pub fn dc_msg_load_from_db<'a>(context: &'a Context, id: u32) -> Result<Message<
params![id as i32],
|row| {
unsafe {
let mut msg = dc_msg_new_untyped(context);
msg.context = context;
let mut msg = dc_msg_new_untyped();
msg.id = row.get::<_, i32>(0)? as u32;
msg.rfc724_mid = row.get::<_, String>(1)?.strdup();
msg.in_reply_to = match row.get::<_, Option<String>>(2)? {
@@ -643,7 +640,7 @@ pub fn dc_star_msgs(
.is_ok()
}
pub fn dc_get_msg<'a>(context: &'a Context, msg_id: u32) -> Result<Message<'a>, Error> {
pub fn dc_get_msg(context: &Context, msg_id: u32) -> Result<Message, Error> {
dc_msg_load_from_db(context, msg_id)
}
@@ -701,11 +698,10 @@ pub unsafe fn dc_msg_get_filename(msg: &Message) -> *mut libc::c_char {
}
}
pub unsafe fn dc_msg_get_filebytes(msg: &Message) -> uint64_t {
pub fn dc_msg_get_filebytes(context: &Context, msg: &Message) -> uint64_t {
if let Some(file) = msg.param.get(Param::File) {
return dc_get_filebytes(msg.context, &file);
return dc_get_filebytes(context, &file);
}
0
}
@@ -730,14 +726,14 @@ pub fn dc_msg_get_showpadlock(msg: &Message) -> libc::c_int {
0
}
pub unsafe fn dc_msg_get_summary<'a>(msg: &mut Message<'a>, chat: Option<&Chat<'a>>) -> Lot {
pub fn dc_msg_get_summary(context: &Context, msg: &mut Message, chat: Option<&Chat>) -> Lot {
let mut ret = Lot::new();
let chat_loaded: Chat;
let chat = if let Some(chat) = chat {
chat
} else {
if let Ok(chat) = Chat::load_from_db(msg.context, msg.chat_id) {
if let Ok(chat) = Chat::load_from_db(context, msg.chat_id) {
chat_loaded = chat;
&chat_loaded
} else {
@@ -753,12 +749,13 @@ pub unsafe fn dc_msg_get_summary<'a>(msg: &mut Message<'a>, chat: Option<&Chat<'
None
};
ret.fill(msg, chat, contact.as_ref(), msg.context);
ret.fill(msg, chat, contact.as_ref(), context);
ret
}
pub unsafe fn dc_msg_get_summarytext(
context: &Context,
msg: &mut Message,
approx_characters: usize,
) -> *mut libc::c_char {
@@ -767,7 +764,7 @@ pub unsafe fn dc_msg_get_summarytext(
msg.text.as_ref(),
&mut msg.param,
approx_characters,
msg.context,
context,
)
.strdup()
}
@@ -898,7 +895,7 @@ pub fn dc_msg_is_setupmessage(msg: &Message) -> bool {
msg.param.get_int(Param::Cmd) == Some(6)
}
pub unsafe fn dc_msg_get_setupcodebegin(msg: &Message) -> *mut libc::c_char {
pub unsafe fn dc_msg_get_setupcodebegin(context: &Context, msg: &Message) -> *mut libc::c_char {
let mut filename: *mut libc::c_char = ptr::null_mut();
let mut buf: *mut libc::c_char = ptr::null_mut();
let mut buf_bytes: size_t = 0i32 as size_t;
@@ -908,11 +905,11 @@ pub unsafe fn dc_msg_get_setupcodebegin(msg: &Message) -> *mut libc::c_char {
let mut buf_setupcodebegin: *const libc::c_char = ptr::null();
let mut ret: *mut libc::c_char = ptr::null_mut();
if dc_msg_is_setupmessage(msg) {
filename = dc_msg_get_file(msg);
filename = dc_msg_get_file(context, msg);
if !(filename.is_null() || *filename.offset(0isize) as libc::c_int == 0i32) {
if !(0
== dc_read_file(
msg.context,
context,
filename,
&mut buf as *mut *mut libc::c_char as *mut *mut libc::c_void,
&mut buf_bytes,
@@ -977,6 +974,7 @@ pub fn dc_msg_set_duration(msg: &mut Message, duration: libc::c_int) {
}
pub fn dc_msg_latefiling_mediasize(
context: &Context,
msg: &mut Message,
width: libc::c_int,
height: libc::c_int,
@@ -989,20 +987,20 @@ pub fn dc_msg_latefiling_mediasize(
if duration > 0 {
msg.param.set_int(Param::Duration, duration);
}
dc_msg_save_param_to_disk(msg);
dc_msg_save_param_to_disk(context, msg);
}
pub fn dc_msg_save_param_to_disk(msg: &mut Message) -> bool {
pub fn dc_msg_save_param_to_disk(context: &Context, msg: &mut Message) -> bool {
sql::execute(
msg.context,
&msg.context.sql,
context,
&context.sql,
"UPDATE msgs SET param=? WHERE id=?;",
params![msg.param.to_string(), msg.id as i32],
)
.is_ok()
}
pub fn dc_msg_new_load<'a>(context: &'a Context, msg_id: u32) -> Result<Message<'a>, Error> {
pub fn dc_msg_new_load(context: &Context, msg_id: u32) -> Result<Message, Error> {
dc_msg_load_from_db(context, msg_id)
}
@@ -1321,7 +1319,7 @@ mod tests {
let chat = chat::create_by_contact_id(ctx, contact).unwrap();
let mut msg = dc_msg_new(ctx, Viewtype::Text);
let mut msg = dc_msg_new(Viewtype::Text);
let msg_id = chat::prepare_msg(ctx, chat, &mut msg).unwrap();

2
src/securejoin.rs
View File

@@ -274,7 +274,7 @@ fn send_handshake_msg(
fingerprint: Option<String>,
grpid: impl AsRef<str>,
) {
let mut msg = unsafe { dc_msg_new_untyped(context) };
let mut msg = dc_msg_new_untyped();
msg.type_0 = Viewtype::Text;
msg.text = Some(format!("Secure-Join: {}", step));
msg.hidden = true;