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

it compiles

Browse Source
This commit is contained in:
dignifiedquire
2019-05-01 22:53:42 +02:00
parent 1abc53f757
commit 313f71a004
33 changed files with 2456 additions and 1953 deletions
Download Patch File Download Diff File Expand all files Collapse all files

416
src/dc_location.rs
View File

@@ -51,16 +51,14 @@ pub unsafe fn dc_send_locations_to_chat(
let mut msg: *mut dc_msg_t = 0 as *mut dc_msg_t;
let mut stock_str: *mut libc::c_char = 0 as *mut libc::c_char;
let mut is_sending_locations_before: libc::c_int = 0i32;
if !(context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| seconds < 0i32
|| chat_id <= 9i32 as libc::c_uint)
{
if !(seconds < 0i32 || chat_id <= 9i32 as libc::c_uint) {
is_sending_locations_before = dc_is_sending_locations_to_chat(context, chat_id);
stmt =
dc_sqlite3_prepare((*context).sql,
b"UPDATE chats SET locations_send_begin=?, locations_send_until=? WHERE id=?\x00"
as *const u8 as *const libc::c_char);
dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE chats SET locations_send_begin=?, locations_send_until=? WHERE id=?\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int64(
stmt,
1i32,
@@ -102,7 +100,7 @@ pub unsafe fn dc_send_locations_to_chat(
);
dc_add_device_msg(context, chat_id, stock_str);
}
((*context).cb)(
(context.cb)(
context,
Event::CHAT_MODIFIED,
chat_id as uintptr_t,
@@ -137,27 +135,28 @@ pub unsafe extern "C" fn dc_is_sending_locations_to_chat(
) -> libc::c_int {
let mut is_sending_locations: libc::c_int = 0i32;
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
stmt = dc_sqlite3_prepare(
(*context).sql,
b"SELECT id FROM chats WHERE (? OR id=?) AND locations_send_until>?;\x00"
as *const u8 as *const libc::c_char,
);
sqlite3_bind_int(
stmt,
1i32,
if chat_id == 0i32 as libc::c_uint {
1i32
} else {
0i32
},
);
sqlite3_bind_int(stmt, 2i32, chat_id as libc::c_int);
sqlite3_bind_int64(stmt, 3i32, time(0 as *mut time_t) as sqlite3_int64);
if !(sqlite3_step(stmt) != 100i32) {
is_sending_locations = 1i32
}
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id FROM chats WHERE (? OR id=?) AND locations_send_until>?;\x00" as *const u8
as *const libc::c_char,
);
sqlite3_bind_int(
stmt,
1i32,
if chat_id == 0i32 as libc::c_uint {
1i32
} else {
0i32
},
);
sqlite3_bind_int(stmt, 2i32, chat_id as libc::c_int);
sqlite3_bind_int64(stmt, 3i32, time(0 as *mut time_t) as sqlite3_int64);
if !(sqlite3_step(stmt) != 100i32) {
is_sending_locations = 1i32
}
sqlite3_finalize(stmt);
return is_sending_locations;
}
@@ -170,14 +169,12 @@ pub unsafe fn dc_set_location(
let mut stmt_chats: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
let mut stmt_insert: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
let mut continue_streaming: libc::c_int = 0i32;
if context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| latitude == 0.0f64 && longitude == 0.0f64
{
if latitude == 0.0f64 && longitude == 0.0f64 {
continue_streaming = 1i32
} else {
stmt_chats = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id FROM chats WHERE locations_send_until>?;\x00" as *const u8
as *const libc::c_char,
);
@@ -185,9 +182,11 @@ pub unsafe fn dc_set_location(
while sqlite3_step(stmt_chats) == 100i32 {
let mut chat_id: uint32_t = sqlite3_column_int(stmt_chats, 0i32) as uint32_t;
stmt_insert =
dc_sqlite3_prepare((*context).sql,
b"INSERT INTO locations (latitude, longitude, accuracy, timestamp, chat_id, from_id) VALUES (?,?,?,?,?,?);\x00"
as *const u8 as *const libc::c_char);
dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"INSERT INTO locations (latitude, longitude, accuracy, timestamp, chat_id, from_id) VALUES (?,?,?,?,?,?);\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_double(stmt_insert, 1i32, latitude);
sqlite3_bind_double(stmt_insert, 2i32, longitude);
sqlite3_bind_double(stmt_insert, 3i32, accuracy);
@@ -198,7 +197,7 @@ pub unsafe fn dc_set_location(
continue_streaming = 1i32
}
if 0 != continue_streaming {
((*context).cb)(
(context.cb)(
context,
Event::LOCATION_CHANGED,
1i32 as uintptr_t,
@@ -218,70 +217,71 @@ pub unsafe fn dc_get_locations(
mut timestamp_from: time_t,
mut timestamp_to: time_t,
) -> *mut dc_array_t {
let mut ret: *mut dc_array_t = dc_array_new_typed(context, 1i32, 500i32 as size_t);
let mut ret: *mut dc_array_t = dc_array_new_typed(1i32, 500i32 as size_t);
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
if timestamp_to == 0i32 as libc::c_long {
timestamp_to = time(0 as *mut time_t) + 10i32 as libc::c_long
}
stmt = dc_sqlite3_prepare(
(*context).sql,
b"SELECT l.id, l.latitude, l.longitude, l.accuracy, l.timestamp, l.independent \
if timestamp_to == 0i32 as libc::c_long {
timestamp_to = time(0 as *mut time_t) + 10i32 as libc::c_long
}
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT l.id, l.latitude, l.longitude, l.accuracy, l.timestamp, l.independent \
m.id, l.from_id, l.chat_id, m.txt \
FROM locations l LEFT JOIN msgs m ON l.id=m.location_id WHERE (? OR l.chat_id=?) \
AND (? OR l.from_id=?) \
AND (l.independent=1 OR (l.timestamp>=? AND l.timestamp<=?)) \
ORDER BY l.timestamp DESC, l.id DESC, m.id DESC;\x00" as *const u8
as *const libc::c_char,
);
sqlite3_bind_int(
stmt,
1i32,
if chat_id == 0i32 as libc::c_uint {
1i32
} else {
0i32
},
);
sqlite3_bind_int(stmt, 2i32, chat_id as libc::c_int);
sqlite3_bind_int(
stmt,
3i32,
if contact_id == 0i32 as libc::c_uint {
1i32
} else {
0i32
},
);
sqlite3_bind_int(stmt, 4i32, contact_id as libc::c_int);
sqlite3_bind_int(stmt, 5i32, timestamp_from as libc::c_int);
sqlite3_bind_int(stmt, 6i32, timestamp_to as libc::c_int);
while sqlite3_step(stmt) == 100i32 {
let mut loc: *mut _dc_location =
calloc(1, ::std::mem::size_of::<_dc_location>()) as *mut _dc_location;
if loc.is_null() {
break;
}
(*loc).location_id = sqlite3_column_double(stmt, 0i32) as uint32_t;
(*loc).latitude = sqlite3_column_double(stmt, 1i32);
(*loc).longitude = sqlite3_column_double(stmt, 2i32);
(*loc).accuracy = sqlite3_column_double(stmt, 3i32);
(*loc).timestamp = sqlite3_column_int64(stmt, 4i32) as time_t;
(*loc).independent = sqlite3_column_int(stmt, 5i32) as uint32_t;
(*loc).msg_id = sqlite3_column_int(stmt, 6i32) as uint32_t;
(*loc).contact_id = sqlite3_column_int(stmt, 7i32) as uint32_t;
(*loc).chat_id = sqlite3_column_int(stmt, 8i32) as uint32_t;
if 0 != (*loc).msg_id {
let mut txt: *const libc::c_char =
sqlite3_column_text(stmt, 9i32) as *const libc::c_char;
if 0 != is_marker(txt) {
(*loc).marker = strdup(txt)
}
}
dc_array_add_ptr(ret, loc as *mut libc::c_void);
as *const libc::c_char,
);
sqlite3_bind_int(
stmt,
1i32,
if chat_id == 0i32 as libc::c_uint {
1i32
} else {
0i32
},
);
sqlite3_bind_int(stmt, 2i32, chat_id as libc::c_int);
sqlite3_bind_int(
stmt,
3i32,
if contact_id == 0i32 as libc::c_uint {
1i32
} else {
0i32
},
);
sqlite3_bind_int(stmt, 4i32, contact_id as libc::c_int);
sqlite3_bind_int(stmt, 5i32, timestamp_from as libc::c_int);
sqlite3_bind_int(stmt, 6i32, timestamp_to as libc::c_int);
while sqlite3_step(stmt) == 100i32 {
let mut loc: *mut _dc_location =
calloc(1, ::std::mem::size_of::<_dc_location>()) as *mut _dc_location;
if loc.is_null() {
break;
}
(*loc).location_id = sqlite3_column_double(stmt, 0i32) as uint32_t;
(*loc).latitude = sqlite3_column_double(stmt, 1i32);
(*loc).longitude = sqlite3_column_double(stmt, 2i32);
(*loc).accuracy = sqlite3_column_double(stmt, 3i32);
(*loc).timestamp = sqlite3_column_int64(stmt, 4i32) as time_t;
(*loc).independent = sqlite3_column_int(stmt, 5i32) as uint32_t;
(*loc).msg_id = sqlite3_column_int(stmt, 6i32) as uint32_t;
(*loc).contact_id = sqlite3_column_int(stmt, 7i32) as uint32_t;
(*loc).chat_id = sqlite3_column_int(stmt, 8i32) as uint32_t;
if 0 != (*loc).msg_id {
let mut txt: *const libc::c_char =
sqlite3_column_text(stmt, 9i32) as *const libc::c_char;
if 0 != is_marker(txt) {
(*loc).marker = strdup(txt)
}
}
dc_array_add_ptr(ret, loc as *mut libc::c_void);
}
sqlite3_finalize(stmt);
return ret;
}
@@ -296,19 +296,20 @@ unsafe fn is_marker(mut txt: *const libc::c_char) -> libc::c_int {
}
pub unsafe fn dc_delete_all_locations(mut context: &dc_context_t) {
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
stmt = dc_sqlite3_prepare(
(*context).sql,
b"DELETE FROM locations;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_step(stmt);
((*context).cb)(
context,
Event::LOCATION_CHANGED,
0i32 as uintptr_t,
0i32 as uintptr_t,
);
}
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"DELETE FROM locations;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_step(stmt);
(context.cb)(
context,
Event::LOCATION_CHANGED,
0i32 as uintptr_t,
0i32 as uintptr_t,
);
sqlite3_finalize(stmt);
}
pub unsafe fn dc_get_location_kml(
@@ -331,30 +332,34 @@ pub unsafe fn dc_get_location_kml(
eos: 0 as *mut libc::c_char,
};
dc_strbuilder_init(&mut ret, 1000i32);
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
self_addr = dc_sqlite3_get_config(
(*context).sql,
b"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\x00" as *const u8 as *const libc::c_char,
);
stmt =
dc_sqlite3_prepare((*context).sql,
b"SELECT locations_send_begin, locations_send_until, locations_last_sent FROM chats WHERE id=?;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int);
if !(sqlite3_step(stmt) != 100i32) {
locations_send_begin = sqlite3_column_int64(stmt, 0i32) as time_t;
locations_send_until = sqlite3_column_int64(stmt, 1i32) as time_t;
locations_last_sent = sqlite3_column_int64(stmt, 2i32) as time_t;
sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt;
if !(locations_send_begin == 0i32 as libc::c_long || now > locations_send_until) {
dc_strbuilder_catf(&mut ret as *mut dc_strbuilder_t,
self_addr = dc_sqlite3_get_config(
context,
&mut context.sql.clone().lock().unwrap(),
b"configured_addr\x00" as *const u8 as *const libc::c_char,
b"\x00" as *const u8 as *const libc::c_char,
);
stmt =
dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT locations_send_begin, locations_send_until, locations_last_sent FROM chats WHERE id=?;\x00"
as *const u8 as *const libc::c_char);
sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int);
if !(sqlite3_step(stmt) != 100i32) {
locations_send_begin = sqlite3_column_int64(stmt, 0i32) as time_t;
locations_send_until = sqlite3_column_int64(stmt, 1i32) as time_t;
locations_last_sent = sqlite3_column_int64(stmt, 2i32) as time_t;
sqlite3_finalize(stmt);
stmt = 0 as *mut sqlite3_stmt;
if !(locations_send_begin == 0i32 as libc::c_long || now > locations_send_until) {
dc_strbuilder_catf(&mut ret as *mut dc_strbuilder_t,
b"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<kml xmlns=\"http://www.opengis.net/kml/2.2\">\n<Document addr=\"%s\">\n\x00"
as *const u8 as *const libc::c_char,
self_addr);
stmt = dc_sqlite3_prepare(
(*context).sql,
stmt = dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id, latitude, longitude, accuracy, timestamp\
FROM locations WHERE from_id=? \
AND timestamp>=? \
@@ -365,44 +370,41 @@ pub unsafe fn dc_get_location_kml(
as *const libc::c_char,
);
sqlite3_bind_int(stmt, 1i32, 1i32);
sqlite3_bind_int64(stmt, 2i32, locations_send_begin as sqlite3_int64);
sqlite3_bind_int64(stmt, 3i32, locations_last_sent as sqlite3_int64);
sqlite3_bind_int(stmt, 4i32, 1i32);
while sqlite3_step(stmt) == 100i32 {
let mut location_id: uint32_t = sqlite3_column_int(stmt, 0i32) as uint32_t;
let mut latitude: *mut libc::c_char =
dc_ftoa(sqlite3_column_double(stmt, 1i32));
let mut longitude: *mut libc::c_char =
dc_ftoa(sqlite3_column_double(stmt, 2i32));
let mut accuracy: *mut libc::c_char =
dc_ftoa(sqlite3_column_double(stmt, 3i32));
let mut timestamp: *mut libc::c_char =
get_kml_timestamp(sqlite3_column_int64(stmt, 4i32) as time_t);
dc_strbuilder_catf(&mut ret as *mut dc_strbuilder_t,
sqlite3_bind_int(stmt, 1i32, 1i32);
sqlite3_bind_int64(stmt, 2i32, locations_send_begin as sqlite3_int64);
sqlite3_bind_int64(stmt, 3i32, locations_last_sent as sqlite3_int64);
sqlite3_bind_int(stmt, 4i32, 1i32);
while sqlite3_step(stmt) == 100i32 {
let mut location_id: uint32_t = sqlite3_column_int(stmt, 0i32) as uint32_t;
let mut latitude: *mut libc::c_char = dc_ftoa(sqlite3_column_double(stmt, 1i32));
let mut longitude: *mut libc::c_char = dc_ftoa(sqlite3_column_double(stmt, 2i32));
let mut accuracy: *mut libc::c_char = dc_ftoa(sqlite3_column_double(stmt, 3i32));
let mut timestamp: *mut libc::c_char =
get_kml_timestamp(sqlite3_column_int64(stmt, 4i32) as time_t);
dc_strbuilder_catf(&mut ret as *mut dc_strbuilder_t,
b"<Placemark><Timestamp><when>%s</when></Timestamp><Point><coordinates accuracy=\"%s\">%s,%s</coordinates></Point></Placemark>\n\x00"
as *const u8 as
*const libc::c_char, timestamp,
accuracy, longitude, latitude);
location_count += 1;
if !last_added_location_id.is_null() {
*last_added_location_id = location_id
}
free(latitude as *mut libc::c_void);
free(longitude as *mut libc::c_void);
free(accuracy as *mut libc::c_void);
free(timestamp as *mut libc::c_void);
}
if !(location_count == 0i32) {
dc_strbuilder_cat(
&mut ret,
b"</Document>\n</kml>\x00" as *const u8 as *const libc::c_char,
);
success = 1i32
location_count += 1;
if !last_added_location_id.is_null() {
*last_added_location_id = location_id
}
free(latitude as *mut libc::c_void);
free(longitude as *mut libc::c_void);
free(accuracy as *mut libc::c_void);
free(timestamp as *mut libc::c_void);
}
if !(location_count == 0i32) {
dc_strbuilder_cat(
&mut ret,
b"</Document>\n</kml>\x00" as *const u8 as *const libc::c_char,
);
success = 1i32
}
}
}
sqlite3_finalize(stmt);
free(self_addr as *mut libc::c_void);
if 0 == success {
@@ -449,15 +451,10 @@ unsafe fn get_kml_timestamp(mut utc: time_t) -> *mut libc::c_char {
}
pub unsafe fn dc_get_message_kml(
context: &dc_context_t,
timestamp: time_t,
latitude: libc::c_double,
longitude: libc::c_double,
) -> *mut libc::c_char {
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
return std::ptr::null_mut();
}
let timestamp_str = get_kml_timestamp(timestamp);
let latitude_str = dc_ftoa(latitude);
let longitude_str = dc_ftoa(longitude);
@@ -485,13 +482,14 @@ pub unsafe fn dc_get_message_kml(
}
pub unsafe fn dc_set_kml_sent_timestamp(
mut context: &dc_context_t,
mut chat_id: uint32_t,
mut timestamp: time_t,
context: &dc_context_t,
chat_id: uint32_t,
timestamp: time_t,
) {
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE chats SET locations_last_sent=? WHERE id=?;\x00" as *const u8
as *const libc::c_char,
);
@@ -507,7 +505,8 @@ pub unsafe fn dc_set_msg_location_id(
) {
let mut stmt: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE msgs SET location_id=? WHERE id=?;\x00" as *const u8 as *const libc::c_char,
);
sqlite3_bind_int64(stmt, 1i32, location_id as sqlite3_int64);
@@ -526,18 +525,16 @@ pub unsafe fn dc_save_locations(
let mut stmt_insert: *mut sqlite3_stmt = 0 as *mut sqlite3_stmt;
let mut newest_timestamp: time_t = 0i32 as time_t;
let mut newest_location_id: uint32_t = 0i32 as uint32_t;
if !(context.is_null()
|| (*context).magic != 0x11a11807i32 as libc::c_uint
|| chat_id <= 9i32 as libc::c_uint
|| locations.is_null())
{
if !(chat_id <= 9i32 as libc::c_uint || locations.is_null()) {
stmt_test = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id FROM locations WHERE timestamp=? AND from_id=?\x00" as *const u8
as *const libc::c_char,
);
stmt_insert = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"INSERT INTO locations\
(timestamp, from_id, chat_id, latitude, longitude, accuracy, independent) \
VALUES (?,?,?,?,?,?,?);\x00" as *const u8 as *const libc::c_char,
@@ -563,7 +560,8 @@ pub unsafe fn dc_save_locations(
if (*location).timestamp > newest_timestamp {
newest_timestamp = (*location).timestamp;
newest_location_id = dc_sqlite3_get_rowid2(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"locations\x00" as *const u8 as *const libc::c_char,
b"timestamp\x00" as *const u8 as *const libc::c_char,
(*location).timestamp as uint64_t,
@@ -591,33 +589,34 @@ pub unsafe fn dc_kml_parse(
text_cb: None,
userdata: 0 as *mut libc::c_void,
};
if !(context.is_null() || (*context).magic != 0x11a11807i32 as libc::c_uint) {
if content_bytes > (1 * 1024 * 1024) {
dc_log_warning(
context,
0,
b"A kml-files with %i bytes is larger than reasonably expected.\x00" as *const u8
as *const libc::c_char,
content_bytes,
if content_bytes > (1 * 1024 * 1024) {
dc_log_warning(
context,
0,
b"A kml-files with %i bytes is larger than reasonably expected.\x00" as *const u8
as *const libc::c_char,
content_bytes,
);
} else {
content_nullterminated = dc_null_terminate(content, content_bytes as libc::c_int);
if !content_nullterminated.is_null() {
(*kml).locations = dc_array_new_typed(1, 100 as size_t);
dc_saxparser_init(&mut saxparser, kml as *mut libc::c_void);
dc_saxparser_set_tag_handler(
&mut saxparser,
Some(kml_starttag_cb),
Some(kml_endtag_cb),
);
} else {
content_nullterminated = dc_null_terminate(content, content_bytes as libc::c_int);
if !content_nullterminated.is_null() {
(*kml).locations = dc_array_new_typed(context, 1, 100 as size_t);
dc_saxparser_init(&mut saxparser, kml as *mut libc::c_void);
dc_saxparser_set_tag_handler(
&mut saxparser,
Some(kml_starttag_cb),
Some(kml_endtag_cb),
);
dc_saxparser_set_text_handler(&mut saxparser, Some(kml_text_cb));
dc_saxparser_parse(&mut saxparser, content_nullterminated);
}
dc_saxparser_set_text_handler(&mut saxparser, Some(kml_text_cb));
dc_saxparser_parse(&mut saxparser, content_nullterminated);
}
}
free(content_nullterminated as *mut libc::c_void);
return kml;
}
unsafe fn kml_text_cb(userdata: *mut libc::c_void, text: *const libc::c_char, _len: libc::c_int) {
let mut kml: *mut dc_kml_t = userdata as *mut dc_kml_t;
if 0 != (*kml).tag & (0x4 | 0x10) {
@@ -774,7 +773,8 @@ pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOCATIONS(context: &dc_context_t, _job
as *const libc::c_char,
);
stmt_chats = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id, locations_send_begin, locations_last_sent\
FROM chats\
WHERE locations_send_until>?;\x00" as *const u8 as *const libc::c_char,
@@ -791,7 +791,8 @@ pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOCATIONS(context: &dc_context_t, _job
}
if stmt_locations.is_null() {
stmt_locations = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT id \
FROM locations \
WHERE from_id=? \
@@ -842,10 +843,11 @@ pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOC_ENDED(
let mut chat_id: uint32_t = (*job).foreign_id;
let mut locations_send_begin: time_t = 0i32 as time_t;
let mut locations_send_until: time_t = 0i32 as time_t;
let mut stmt: &sqlite3_stmt = 0 as *mut sqlite3_stmt;
let mut stmt = 0 as *mut sqlite3_stmt;
let mut stock_str: *mut libc::c_char = 0 as *mut libc::c_char;
stmt = dc_sqlite3_prepare(
(*context).sql,
context,
&mut context.sql.clone().lock().unwrap(),
b"SELECT locations_send_begin, locations_send_until FROM chats WHERE id=?\x00"
as *const u8 as *const libc::c_char,
);
@@ -866,10 +868,12 @@ pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOC_ENDED(
{
// not streaming, device-message already sent
stmt =
dc_sqlite3_prepare((*context).sql,
b"UPDATE chats SET locations_send_begin=0, locations_send_until=0 WHERE id=?\x00"
as *const u8 as
*const libc::c_char);
dc_sqlite3_prepare(
context,
&mut context.sql.clone().lock().unwrap(),
b"UPDATE chats SET locations_send_begin=0, locations_send_until=0 WHERE id=?\x00"
as *const u8 as
*const libc::c_char);
sqlite3_bind_int(stmt, 1i32, chat_id as libc::c_int);
sqlite3_step(stmt);
stock_str = dc_stock_system_msg(
@@ -880,7 +884,7 @@ pub unsafe fn dc_job_do_DC_JOB_MAYBE_SEND_LOC_ENDED(
0i32 as uint32_t,
);
dc_add_device_msg(context, chat_id, stock_str);
((*context).cb)(
(context.cb)(
context,
Event::CHAT_MODIFIED,
chat_id as uintptr_t,