[wip]

and perform slightly cleaner teardown in python

CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog 
 
-## untagged 1.0.0-beta.7 
+## 1.0.0-beta.7
 
 - fix location-streaming #782
 

Cargo.lock

@@ -480,7 +480,7 @@ dependencies = [
 
 [[package]]
 name = "deltachat"
-version = "1.0.0-beta.6"
+version = "1.0.0-beta.7"
 dependencies = [
  "backtrace 0.3.40 (registry+https://github.com/rust-lang/crates.io-index)",
  "base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -550,9 +550,9 @@ dependencies = [
 
 [[package]]
 name = "deltachat_ffi"
-version = "1.0.0-beta.6"
+version = "1.0.0-beta.7"
 dependencies = [
- "deltachat 1.0.0-beta.6",
+ "deltachat 1.0.0-beta.7",
  "deltachat-provider-database 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "human-panic 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "libc 0.2.65 (registry+https://github.com/rust-lang/crates.io-index)",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat"
-version = "1.0.0-beta.6"
+version = "1.0.0-beta.7"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"
 license = "MPL"

deltachat-ffi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat_ffi"
-version = "1.0.0-beta.6"
+version = "1.0.0-beta.7"
 description = "Deltachat FFI"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"

deltachat-ffi/deltachat.h

@@ -1098,6 +1098,27 @@ uint32_t        dc_send_text_msg             (dc_context_t* context, uint32_t ch
 void            dc_set_draft                 (dc_context_t* context, uint32_t chat_id, dc_msg_t* msg);
 
 
+/**
+ * Add a message to the device-chat.
+ * Device-messages usually contain update information
+ * and some hints that are added during the program runs, multi-device etc.
+ *
+ * Device-messages may be added from the core,
+ * however, with this function, this can be done from the ui as well.
+ * If needed, the device-chat is created before.
+ *
+ * Sends the event #DC_EVENT_MSGS_CHANGED on success.
+ * To check, if a given chat is a device-chat, see dc_chat_is_device_talk()
+ *
+ * @memberof dc_context_t
+ * @param context The context as created by dc_context_new().
+ * @param msg Message to be added to the device-chat.
+ *     The message appears to the user as an incoming message.
+ * @return The ID of the added message.
+ */
+uint32_t        dc_add_device_msg            (dc_context_t* context, dc_msg_t* msg);
+
+
 /**
  * Get draft for a chat, if any.
  * See dc_set_draft() for more details about drafts.
@@ -2715,6 +2736,39 @@ int             dc_chat_is_unpromoted        (const dc_chat_t* chat);
 int             dc_chat_is_self_talk         (const dc_chat_t* chat);
 
 
+/**
+ * Check if a chat is a device-talk.
+ * Device-talks contain update information
+ * and some hints that are added during the program runs, multi-device etc.
+ *
+ * From the ui view, device-talks are not very special,
+ * the user can delete and forward messages, archive the chat, set notifications etc.
+ *
+ * Messages may be added from the core to the device chat,
+ * so the chat just pops up as usual.
+ * However, if needed the ui can also add messages using dc_add_device_msg()
+ *
+ * @memberof dc_chat_t
+ * @param chat The chat object.
+ * @return 1=chat is device-talk, 0=chat is no device-talk
+ */
+int             dc_chat_is_device_talk       (const dc_chat_t* chat);
+
+
+/**
+ * Check if messages can be sent to a give chat.
+ * This is not true eg. for the deaddrop or for the device-talk, cmp. dc_chat_is_device_talk().
+ *
+ * Calling dc_send_msg() for these chats will fail
+ * and the ui may decide to hide input controls therefore.
+ *
+ * @memberof dc_chat_t
+ * @param chat The chat object.
+ * @return 1=chat is writable, 0=chat is not writable
+ */
+int             dc_chat_can_send              (const dc_chat_t* chat);
+
+
 /**
  * Check if a chat is verified.  Verified chats contain only verified members
  * and encryption is alwasy enabled.  Verified chats are created using
@@ -2951,32 +3005,6 @@ int64_t          dc_msg_get_sort_timestamp     (const dc_msg_t* msg);
  */
 char*           dc_msg_get_text               (const dc_msg_t* msg);
 
-/**
- * Get the text of the message.
- * If there is no text associated with the message, an empty string is returned.
- * NULL is never returned.
- *
- * Same as dc_msg_get_text, but isn't truncated
- *
- * To get information about the message and more/raw text, use dc_get_msg_info().
- *
- * @memberof dc_msg_t
- * @param msg The message object.
- * @return Message text. The result must be released using dc_str_unref(). Never returns NULL.
- */
-char*           dc_msg_get_full_text          (const dc_msg_t* msg);
-
-
-/**
- * Check if a message is truncated.
- *
- * @memberof dc_msg_t
- * @param msg The message object.
- * @return 1=message is truncated, 0=message not truncated.
- */
-int             dc_msg_is_truncated            (const dc_msg_t* msg);
-
-// define DC_MSG_TRUNCATE_THRESHOLD
 
 /**
  * Find out full path, file name and extension of the file associated with a
@@ -3396,7 +3424,8 @@ void            dc_msg_latefiling_mediasize   (dc_msg_t* msg, int width, int hei
 
 
 #define         DC_CONTACT_ID_SELF           1
-#define         DC_CONTACT_ID_DEVICE         2
+#define         DC_CONTACT_ID_INFO           2 // centered messages as "member added", used in all chats
+#define         DC_CONTACT_ID_DEVICE         5 // messages "update info" in the device-chat
 #define         DC_CONTACT_ID_LAST_SPECIAL   9
 
 

deltachat-ffi/src/lib.rs

@@ -811,6 +811,23 @@ pub unsafe extern "C" fn dc_set_draft(
         .unwrap_or(())
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn dc_add_device_msg(context: *mut dc_context_t, msg: *mut dc_msg_t) -> u32 {
+    if context.is_null() || msg.is_null() {
+        eprintln!("ignoring careless call to dc_add_device_msg()");
+        return 0;
+    }
+    let ffi_context = &mut *context;
+    let ffi_msg = &mut *msg;
+    ffi_context
+        .with_inner(|ctx| {
+            chat::add_device_msg(ctx, &mut ffi_msg.message)
+                .unwrap_or_log_default(ctx, "Failed to add device message")
+        })
+        .map(|msg_id| msg_id.to_u32())
+        .unwrap_or(0)
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_get_draft(context: *mut dc_context_t, chat_id: u32) -> *mut dc_msg_t {
     if context.is_null() {
@@ -2264,6 +2281,26 @@ pub unsafe extern "C" fn dc_chat_is_self_talk(chat: *mut dc_chat_t) -> libc::c_i
     ffi_chat.chat.is_self_talk() as libc::c_int
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn dc_chat_is_device_talk(chat: *mut dc_chat_t) -> libc::c_int {
+    if chat.is_null() {
+        eprintln!("ignoring careless call to dc_chat_is_device_talk()");
+        return 0;
+    }
+    let ffi_chat = &*chat;
+    ffi_chat.chat.is_device_talk() as libc::c_int
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_chat_can_send(chat: *mut dc_chat_t) -> libc::c_int {
+    if chat.is_null() {
+        eprintln!("ignoring careless call to dc_chat_can_send()");
+        return 0;
+    }
+    let ffi_chat = &*chat;
+    ffi_chat.chat.can_send() as libc::c_int
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_chat_is_verified(chat: *mut dc_chat_t) -> libc::c_int {
     if chat.is_null() {
@@ -2420,26 +2457,7 @@ pub unsafe extern "C" fn dc_msg_get_text(msg: *mut dc_msg_t) -> *mut libc::c_cha
         return dc_strdup(ptr::null());
     }
     let ffi_msg = &*msg;
-    ffi_msg.message.get_text(false).unwrap_or_default().strdup()
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn dc_msg_get_full_text(msg: *mut dc_msg_t) -> *mut libc::c_char {
-    if msg.is_null() {
-        eprintln!("ignoring careless call to dc_msg_get_full_text()");
-        return dc_strdup(ptr::null());
-    }
-    let ffi_msg = &*msg;
-    ffi_msg.message.get_text(true).unwrap_or_default().strdup()
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn is_truncated(msg: *mut dc_msg_t) -> libc::c_int {
-    if msg.is_null() {
-        return 0
-    }
-    let ffi_msg = &*msg;
-    ffi_msg.message.is_truncated().into()
+    ffi_msg.message.get_text().unwrap_or_default().strdup()
 }
 
 #[no_mangle]

examples/repl/cmdline.rs

@@ -189,7 +189,7 @@ unsafe fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
         _ => "",
     };
     let temp2 = dc_timestamp_to_str(msg.get_timestamp());
-    let msgtext = msg.get_text(false);
+    let msgtext = msg.get_text();
     info!(
         context,
         "{}#{}{}{}: {} (Contact#{}): {} {}{}{}{}{} [{}]",
@@ -379,6 +379,7 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
                  sendimage <file> [<text>]\n\
                  sendfile <file> [<text>]\n\
                  draft [<text>]\n\
+                 devicemsg <text>\n\
                  listmedia\n\
                  archive <chat-id>\n\
                  unarchive <chat-id>\n\
@@ -521,13 +522,12 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
 
                 for i in (0..cnt).rev() {
                     let chat = Chat::load_from_db(context, chatlist.get_chat_id(i))?;
-                    let temp_name = chat.get_name();
                     info!(
                         context,
                         "{}#{}: {} [{} fresh]",
                         chat_prefix(&chat),
                         chat.get_id(),
-                        temp_name,
+                        chat.get_name(),
                         chat::get_fresh_msg_cnt(context, chat.get_id()),
                     );
                     let lot = chatlist.get_summary(context, i, Some(&chat));
@@ -586,25 +586,33 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
 
             let msglist = chat::get_chat_msgs(context, sel_chat.get_id(), 0x1, None);
             let members = chat::get_chat_contacts(context, sel_chat.id);
-            let temp2 = if sel_chat.get_type() == Chattype::Single && members.len() >= 1 {
+            let subtitle = if sel_chat.is_device_talk() {
+                "device-talk".to_string()
+            } else if sel_chat.get_type() == Chattype::Single && members.len() >= 1 {
                 let contact = Contact::get_by_id(context, members[0])?;
                 contact.get_addr().to_string()
             } else {
                 format!("{} member(s)", members.len())
             };
-            let temp_name = sel_chat.get_name();
             info!(
                 context,
-                "{}#{}: {} [{}]{}",
+                "{}#{}: {} [{}]{}{}",
                 chat_prefix(sel_chat),
                 sel_chat.get_id(),
-                temp_name,
-                temp2,
+                sel_chat.get_name(),
+                subtitle,
                 if sel_chat.is_sending_locations() {
                     "📍"
                 } else {
                     ""
                 },
+                match sel_chat.get_profile_image(context) {
+                    Some(icon) => match icon.to_str() {
+                        Some(icon) => format!(" Icon: {}", icon),
+                        _ => " Icon: Err".to_string(),
+                    },
+                    _ => "".to_string(),
+                },
             );
             log_msglist(context, &msglist)?;
             if let Some(draft) = chat::get_draft(context, sel_chat.get_id())? {
@@ -822,6 +830,15 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
                 println!("Draft deleted.");
             }
         }
+        "devicemsg" => {
+            ensure!(
+                !arg1.is_empty(),
+                "Please specify text to add as device message."
+            );
+            let mut msg = Message::new(Viewtype::Text);
+            msg.set_text(Some(arg1.to_string()));
+            chat::add_device_msg(context, &mut msg)?;
+        }
         "listmedia" => {
             ensure!(sel_chat.is_some(), "No chat selected.");
 

python/src/deltachat/account.py

@@ -153,6 +153,14 @@ class Account(object):
         self.check_is_configured()
         return from_dc_charpointer(lib.dc_get_info(self._dc_context))
 
+    def get_latest_backupfile(self, backupdir):
+        """ return the latest backup file in a given directory.
+        """
+        res = lib.dc_imex_has_backup(self._dc_context, as_dc_charpointer(backupdir))
+        if res == ffi.NULL:
+            return None
+        return from_dc_charpointer(res)
+
     def get_blobdir(self):
         """ return the directory for files.
 
@@ -477,8 +485,9 @@ class Account(object):
 
     def stop_threads(self, wait=True):
         """ stop IMAP/SMTP threads. """
-        self.stop_ongoing()
-        self._threads.stop(wait=wait)
+        if self._threads.is_started():
+            self.stop_ongoing()
+            self._threads.stop(wait=wait)
 
     def shutdown(self, wait=True):
         """ stop threads and close and remove underlying dc_context and callbacks. """

python/src/deltachat/const.py

@@ -47,7 +47,8 @@ DC_STATE_OUT_FAILED = 24
 DC_STATE_OUT_DELIVERED = 26
 DC_STATE_OUT_MDN_RCVD = 28
 DC_CONTACT_ID_SELF = 1
-DC_CONTACT_ID_DEVICE = 2
+DC_CONTACT_ID_INFO = 2
+DC_CONTACT_ID_DEVICE = 5
 DC_CONTACT_ID_LAST_SPECIAL = 9
 DC_MSG_TEXT = 10
 DC_MSG_IMAGE = 20

python/tests/test_account.py

@@ -2,6 +2,7 @@ from __future__ import print_function
 import pytest
 import os
 import queue
+import time
 from deltachat import const, Account
 from deltachat.message import Message
 from datetime import datetime, timedelta
@@ -641,18 +642,29 @@ class TestOnlineAccount:
         assert os.path.exists(msg_in.filename)
         assert os.stat(msg_in.filename).st_size == os.stat(path).st_size
 
-    def test_import_export_online_all(self, acfactory, tmpdir):
+    def test_import_export_online_all_twice(self, acfactory, tmpdir, lp):
         ac1 = acfactory.get_online_configuring_account()
         wait_configuration_progress(ac1, 1000)
 
+        lp.sec("create some chat content")
         contact1 = ac1.create_contact("some1@hello.com", name="some1")
         chat = ac1.create_chat_by_contact(contact1)
         chat.send_text("msg1")
         backupdir = tmpdir.mkdir("backup")
+
+        lp.sec("export all to {}".format(backupdir))
         path = ac1.export_all(backupdir.strpath)
         assert os.path.exists(path)
+        t = time.time()
 
+        lp.sec("get fresh empty account")
         ac2 = acfactory.get_unconfigured_account()
+
+        lp.sec("get latest backup file")
+        path2 = ac2.get_latest_backupfile(backupdir.strpath)
+        assert path2 == path
+
+        lp.sec("import backup and check it's proper")
         ac2.import_all(path)
         contacts = ac2.get_contacts(query="some1")
         assert len(contacts) == 1
@@ -663,6 +675,17 @@ class TestOnlineAccount:
         assert len(messages) == 1
         assert messages[0].text == "msg1"
 
+        # wait until a second passed since last backup
+        # because get_latest_backupfile() shall return the latest backup
+        # from a UI it's unlikely anyone manages to export two
+        # backups in one second.
+        time.sleep(max(0, 1 - (time.time() - t)))
+        lp.sec("Second-time export all to {}".format(backupdir))
+        path2 = ac1.export_all(backupdir.strpath)
+        assert os.path.exists(path2)
+        assert path2 != path
+        assert ac2.get_latest_backupfile(backupdir.strpath) == path2
+
     def test_ac_setup_message(self, acfactory, lp):
         # note that the receiving account needs to be configured and running
         # before ther setup message is send. DC does not read old messages

src/chat.rs

@@ -97,6 +97,8 @@ impl Chat {
 
                         if chat.param.exists(Param::Selftalk) {
                             chat.name = context.stock_str(StockMessage::SelfMsg).into();
+                        } else if chat.param.exists(Param::Devicetalk) {
+                            chat.name = context.stock_str(StockMessage::DeviceMessages).into();
                         }
                     }
                 }
@@ -109,6 +111,14 @@ impl Chat {
         self.param.exists(Param::Selftalk)
     }
 
+    pub fn is_device_talk(&self) -> bool {
+        self.param.exists(Param::Devicetalk)
+    }
+
+    pub fn can_send(&self) -> bool {
+        self.id > DC_CHAT_ID_LAST_SPECIAL && !self.is_device_talk()
+    }
+
     pub fn update_param(&mut self, context: &Context) -> Result<(), Error> {
         sql::execute(
             context,
@@ -582,6 +592,12 @@ pub fn set_blocking(context: &Context, chat_id: u32, new_blocking: Blocked) -> b
     .is_ok()
 }
 
+fn copy_device_icon_to_blobs(context: &Context) -> Result<String, Error> {
+    let icon = include_bytes!("../assets/icon-device.png");
+    let blob = BlobObject::create(context, "icon-device.png".to_string(), icon)?;
+    Ok(blob.as_name().to_string())
+}
+
 pub fn create_or_lookup_by_contact_id(
     context: &Context,
     contact_id: u32,
@@ -605,7 +621,14 @@ pub fn create_or_lookup_by_contact_id(
             "INSERT INTO chats (type, name, param, blocked, grpid) VALUES({}, '{}', '{}', {}, '{}')",
             100,
             chat_name,
-            if contact_id == DC_CONTACT_ID_SELF as u32 { "K=1" } else { "" },
+            match contact_id {
+                DC_CONTACT_ID_SELF => "K=1".to_string(), // K = Param::Selftalk
+                DC_CONTACT_ID_DEVICE => {
+                    let icon = copy_device_icon_to_blobs(context)?;
+                    format!("D=1\ni={}", icon) // D = Param::Devicetalk, i = Param::ProfileImage
+                },
+                _ => "".to_string()
+            },
             create_blocked as u8,
             contact.get_addr(),
         ),
@@ -677,8 +700,7 @@ pub fn msgtype_has_file(msgtype: Viewtype) -> bool {
     }
 }
 
-fn prepare_msg_common(context: &Context, chat_id: u32, msg: &mut Message) -> Result<MsgId, Error> {
-    msg.id = MsgId::new_unset();
+fn prepare_msg_blob(context: &Context, msg: &mut Message) -> Result<(), Error> {
     if msg.type_0 == Viewtype::Text {
         // the caller should check if the message text is empty
     } else if msgtype_has_file(msg.type_0) {
@@ -714,10 +736,16 @@ fn prepare_msg_common(context: &Context, chat_id: u32, msg: &mut Message) -> Res
     } else {
         bail!("Cannot send messages of type #{}.", msg.type_0);
     }
+    Ok(())
+}
 
+fn prepare_msg_common(context: &Context, chat_id: u32, msg: &mut Message) -> Result<MsgId, Error> {
+    msg.id = MsgId::new_unset();
+    prepare_msg_blob(context, msg)?;
     unarchive(context, chat_id)?;
 
     let mut chat = Chat::load_from_db(context, chat_id)?;
+    ensure!(chat.can_send(), "cannot send to chat #{}", chat_id);
 
     // The OutPreparing state is set by dc_prepare_msg() before it
     // calls this function and the message is left in the OutPreparing
@@ -994,7 +1022,7 @@ pub fn get_chat_msgs(
                 " LEFT JOIN contacts",
                 "        ON m.from_id=contacts.id",
                 " WHERE m.from_id!=1", // 1=DC_CONTACT_ID_SELF
-                "   AND m.from_id!=2", // 2=DC_CONTACT_ID_DEVICE
+                "   AND m.from_id!=2", // 2=DC_CONTACT_ID_INFO
                 "   AND m.hidden=0",
                 "   AND chats.blocked=2",
                 "   AND contacts.blocked=0",
@@ -1898,15 +1926,46 @@ pub fn get_chat_id_by_grpid(context: &Context, grpid: impl AsRef<str>) -> (u32,
         .unwrap_or((0, false, Blocked::Not))
 }
 
-pub fn add_device_msg(context: &Context, chat_id: u32, text: impl AsRef<str>) {
+pub fn add_device_msg(context: &Context, msg: &mut Message) -> Result<MsgId, Error> {
+    let (chat_id, _blocked) =
+        create_or_lookup_by_contact_id(context, DC_CONTACT_ID_DEVICE, Blocked::Not)?;
+    let rfc724_mid = dc_create_outgoing_rfc724_mid(None, "@device");
+
+    prepare_msg_blob(context, msg)?;
+    unarchive(context, chat_id)?;
+
+    context.sql.execute(
+        "INSERT INTO msgs (chat_id,from_id,to_id, timestamp,type,state, txt,param,rfc724_mid) \
+         VALUES (?,?,?, ?,?,?, ?,?,?);",
+        params![
+            chat_id,
+            DC_CONTACT_ID_DEVICE,
+            DC_CONTACT_ID_SELF,
+            dc_create_smeared_timestamp(context),
+            msg.type_0,
+            MessageState::InFresh,
+            msg.text.as_ref().map_or("", String::as_str),
+            msg.param.to_string(),
+            rfc724_mid,
+        ],
+    )?;
+
+    let row_id = sql::get_rowid(context, &context.sql, "msgs", "rfc724_mid", &rfc724_mid);
+    let msg_id = MsgId::new(row_id);
+    context.call_cb(Event::IncomingMsg { chat_id, msg_id });
+
+    Ok(msg_id)
+}
+
+pub fn add_info_msg(context: &Context, chat_id: u32, text: impl AsRef<str>) {
     let rfc724_mid = dc_create_outgoing_rfc724_mid(None, "@device");
 
     if context.sql.execute(
         "INSERT INTO msgs (chat_id,from_id,to_id, timestamp,type,state, txt,rfc724_mid) VALUES (?,?,?, ?,?,?, ?,?);",
         params![
             chat_id as i32,
-            DC_CONTACT_ID_DEVICE,
-            DC_CONTACT_ID_DEVICE,
+            DC_CONTACT_ID_INFO,
+            DC_CONTACT_ID_INFO,
             dc_create_smeared_timestamp(context),
             Viewtype::Text,
             MessageState::InNoticed,

src/constants.rs

@@ -130,7 +130,8 @@ const DC_MAX_GET_INFO_LEN: usize = 100000;
 
 pub const DC_CONTACT_ID_UNDEFINED: u32 = 0;
 pub const DC_CONTACT_ID_SELF: u32 = 1;
-pub const DC_CONTACT_ID_DEVICE: u32 = 2;
+pub const DC_CONTACT_ID_INFO: u32 = 2;
+pub const DC_CONTACT_ID_DEVICE: u32 = 5;
 pub const DC_CONTACT_ID_LAST_SPECIAL: u32 = 9;
 
 pub const DC_CREATE_MVBOX: usize = 1;
@@ -249,8 +250,6 @@ impl Default for Viewtype {
     }
 }
 
-pub const DC_MSG_TRUNCATE_THRESHOLD:usize = 30000;
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/contact.rs

@@ -153,7 +153,16 @@ impl Contact {
                 blocked: false,
                 origin: Origin::Unknown,
             };
-
+            return Ok(contact);
+        } else if contact_id == DC_CONTACT_ID_DEVICE {
+            let contact = Contact {
+                id: contact_id,
+                name: context.stock_str(StockMessage::DeviceMessages).into(),
+                authname: "".into(),
+                addr: "device@localhost".into(),
+                blocked: false,
+                origin: Origin::Unknown,
+            };
             return Ok(contact);
         }
 

src/context.rs

@@ -398,24 +398,21 @@ impl Context {
             .unwrap_or_default()
     }
 
-    pub fn is_inbox(&self, folder_name: impl AsRef<str>) -> bool {
-        folder_name.as_ref() == "INBOX"
+    pub fn is_inbox(&self, folder_name: &str) -> bool {
+        folder_name == "INBOX"
     }
 
-    pub fn is_sentbox(&self, folder_name: impl AsRef<str>) -> bool {
-        let sentbox_name = self.sql.get_raw_config(self, "configured_sentbox_folder");
-        if let Some(name) = sentbox_name {
-            name == folder_name.as_ref()
+    pub fn is_sentbox(&self, folder_name: &str) -> bool {
+        if let Some(name) = self.sql.get_raw_config(self, "configured_sentbox_folder") {
+            name == folder_name
         } else {
             false
         }
     }
 
-    pub fn is_mvbox(&self, folder_name: impl AsRef<str>) -> bool {
-        let mvbox_name = self.sql.get_raw_config(self, "configured_mvbox_folder");
-
-        if let Some(name) = mvbox_name {
-            name == folder_name.as_ref()
+    pub fn is_mvbox(&self, folder_name: &str) -> bool {
+        if let Some(name) = self.sql.get_raw_config(self, "configured_mvbox_folder") {
+            name == folder_name
         } else {
             false
         }

src/dc_receive_imf.rs

@@ -850,7 +850,7 @@ fn save_locations(
     if mime_parser.message_kml.is_some() {
         let locations = &mime_parser.message_kml.as_ref().unwrap().locations;
         let newest_location_id =
-            location::save(context, chat_id, from_id, locations, 1).unwrap_or_default();
+            location::save(context, chat_id, from_id, locations, true).unwrap_or_default();
         if 0 != newest_location_id && 0 == hidden {
             if location::set_msg_location_id(context, insert_msg_id, newest_location_id).is_ok() {
                 location_id_written = true;
@@ -865,7 +865,8 @@ fn save_locations(
                 if contact.get_addr().to_lowercase() == addr.to_lowercase() {
                     let locations = &mime_parser.location_kml.as_ref().unwrap().locations;
                     let newest_location_id =
-                        location::save(context, chat_id, from_id, locations, 0).unwrap_or_default();
+                        location::save(context, chat_id, from_id, locations, false)
+                            .unwrap_or_default();
                     if newest_location_id != 0 && hidden == 0 && !location_id_written {
                         if let Err(err) = location::set_msg_location_id(
                             context,

src/dc_tools.rs

@@ -427,21 +427,55 @@ pub(crate) fn dc_delete_file(context: &Context, path: impl AsRef<std::path::Path
 
 pub(crate) fn dc_copy_file(
     context: &Context,
-    src: impl AsRef<std::path::Path>,
-    dest: impl AsRef<std::path::Path>,
+    src_path: impl AsRef<std::path::Path>,
+    dest_path: impl AsRef<std::path::Path>,
 ) -> bool {
-    let src_abs = dc_get_abs_path(context, &src);
-    let dest_abs = dc_get_abs_path(context, &dest);
-    match fs::copy(&src_abs, &dest_abs) {
+    let src_abs = dc_get_abs_path(context, &src_path);
+    let mut src_file = match fs::File::open(&src_abs) {
+        Ok(file) => file,
+        Err(err) => {
+            warn!(
+                context,
+                "failed to open for read '{}': {}",
+                src_abs.display(),
+                err
+            );
+            return false;
+        }
+    };
+
+    let dest_abs = dc_get_abs_path(context, &dest_path);
+    let mut dest_file = match fs::OpenOptions::new()
+        .create_new(true)
+        .write(true)
+        .open(&dest_abs)
+    {
+        Ok(file) => file,
+        Err(err) => {
+            warn!(
+                context,
+                "failed to open for write '{}': {}",
+                dest_abs.display(),
+                err
+            );
+            return false;
+        }
+    };
+
+    match std::io::copy(&mut src_file, &mut dest_file) {
         Ok(_) => true,
         Err(err) => {
             error!(
                 context,
                 "Cannot copy \"{}\" to \"{}\": {}",
-                src.as_ref().display(),
-                dest.as_ref().display(),
+                src_abs.display(),
+                dest_abs.display(),
                 err
             );
+            {
+                // Attempt to remove the failed file, swallow errors resulting from that.
+                fs::remove_file(dest_abs).ok();
+            }
             false
         }
     }
@@ -1283,6 +1317,9 @@ mod tests {
 
         assert!(dc_copy_file(context, "$BLOBDIR/foobar", "$BLOBDIR/dada",));
 
+        // attempting to copy a second time should fail
+        assert!(!dc_copy_file(context, "$BLOBDIR/foobar", "$BLOBDIR/dada",));
+
         assert_eq!(dc_get_filebytes(context, "$BLOBDIR/dada",), 7);
 
         let buf = dc_read_file(context, "$BLOBDIR/dada").unwrap();

src/imap.rs

@@ -380,10 +380,8 @@ impl Imap {
         self.should_reconnect.load(Ordering::Relaxed)
     }
 
-    fn setup_handle_if_needed(&self, context: &Context) -> bool {
-        if self.config.read().unwrap().imap_server.is_empty() {
-            return false;
-        }
+    fn setup_handle_if_needed(&self, context: &Context) -> Result<(), Error> {
+        ensure!(!self.config.read().unwrap().imap_server.is_empty(), "no imap server configured");
 
         if self.should_reconnect() {
             self.unsetup_handle(context);
@@ -391,7 +389,7 @@ impl Imap {
 
         if self.is_connected() && self.stream.read().unwrap().is_some() {
             self.should_reconnect.store(false, Ordering::Relaxed);
-            return true;
+            return Ok(());
         }
 
         let server_flags = self.config.read().unwrap().server_flags as i32;
@@ -437,7 +435,7 @@ impl Imap {
                         };
                         client.authenticate("XOAUTH2", &auth)
                     } else {
-                        return false;
+                        bail!("could not authenticate with XOAUTH2");
                     }
                 } else {
                     client.login(imap_user, imap_pw)
@@ -455,7 +453,7 @@ impl Imap {
 
                 emit_event!(context, Event::ErrorNetwork(message));
 
-                return false;
+                bail!("login error: {}", err);
             }
         };
 
@@ -465,7 +463,7 @@ impl Imap {
             Ok((session, stream)) => {
                 *self.session.lock().unwrap() = Some(session);
                 *self.stream.write().unwrap() = Some(stream);
-                true
+                Ok(())
             }
             Err((err, _)) => {
                 let imap_user = self.config.read().unwrap().imap_user.to_owned();
@@ -477,7 +475,7 @@ impl Imap {
                 );
                 self.unsetup_handle(context);
 
-                false
+                bail!("{}", err)
             }
         }
     }
@@ -549,7 +547,7 @@ impl Imap {
             config.server_flags = server_flags;
         }
 
-        if !self.setup_handle_if_needed(context) {
+        if self.setup_handle_if_needed(context).is_err() {
             self.free_connect_params();
             return false;
         }
@@ -622,7 +620,7 @@ impl Imap {
             // get any more. if IDLE is called directly after, there is only a small chance that
             // messages are missed and delayed until the next IDLE call
             loop {
-                if self.fetch_from_single_folder(context, watch_folder) == 0 {
+                if self.fetch_from_single_folder(context, watch_folder).is_err() {
                     break;
                 }
             }
@@ -632,69 +630,20 @@ impl Imap {
         }
     }
 
-    fn select_folder<S: AsRef<str>>(&self, context: &Context, folder: Option<S>) -> usize {
-        if self.session.lock().unwrap().is_none() {
-            let mut cfg = self.config.write().unwrap();
-            cfg.selected_folder = None;
-            cfg.selected_folder_needs_expunge = false;
-            return 0;
-        }
+    fn expunge_folder(&self, context: &Context) -> bool {
+        if let Some(ref folder) = self.config.read().unwrap().selected_folder {
+            info!(context, "Expunge messages in \"{}\".", folder);
 
-        // if there is a new folder and the new folder is equal to the selected one, there's nothing to do.
-        // if there is _no_ new folder, we continue as we might want to expunge below.
-        if let Some(ref folder) = folder {
-            if let Some(ref selected_folder) = self.config.read().unwrap().selected_folder {
-                if folder.as_ref() == selected_folder {
-                    return 1;
-                }
-            }
-        }
-
-        // deselect existing folder, if needed (it's also done implicitly by SELECT, however, without EXPUNGE then)
-        let needs_expunge = { self.config.read().unwrap().selected_folder_needs_expunge };
-        if needs_expunge {
-            if let Some(ref folder) = self.config.read().unwrap().selected_folder {
-                info!(context, "Expunge messages in \"{}\".", folder);
-
-                // A CLOSE-SELECT is considerably faster than an EXPUNGE-SELECT, see
-                // https://tools.ietf.org/html/rfc3501#section-6.4.2
-                if let Some(ref mut session) = &mut *self.session.lock().unwrap() {
-                    match session.close() {
-                        Ok(_) => {
-                            info!(context, "close/expunge succeeded");
-                        }
-                        Err(err) => {
-                            warn!(context, "failed to close session: {:?}", err);
-                            return 0;
-                        }
-                    }
-                } else {
-                    return 0;
-                }
-            }
-            self.config.write().unwrap().selected_folder_needs_expunge = false;
-        }
-
-        // select new folder
-        if let Some(ref folder) = folder {
+            // A CLOSE-SELECT is considerably faster than an EXPUNGE-SELECT, see
+            // https://tools.ietf.org/html/rfc3501#section-6.4.2
             if let Some(ref mut session) = &mut *self.session.lock().unwrap() {
-                match session.select(folder) {
-                    Ok(mailbox) => {
-                        let mut config = self.config.write().unwrap();
-                        config.selected_folder = Some(folder.as_ref().to_string());
-                        config.selected_mailbox = Some(mailbox);
+                match session.close() {
+                    Ok(_) => {
+                        info!(context, "close/expunge succeeded");
                     }
                     Err(err) => {
-                        info!(
-                            context,
-                            "Cannot select folder: {}; {:?}.",
-                            folder.as_ref(),
-                            err
-                        );
-
-                        self.config.write().unwrap().selected_folder = None;
-                        self.should_reconnect.store(true, Ordering::Relaxed);
-                        return 0;
+                        warn!(context, "failed to close session: {:?}", err);
+                        return false;
                     }
                 }
             } else {
@@ -702,11 +651,55 @@ impl Imap {
             }
         }
 
-        1
+        true
     }
 
-    fn get_config_last_seen_uid<S: AsRef<str>>(&self, context: &Context, folder: S) -> (u32, u32) {
-        let key = format!("imap.mailbox.{}", folder.as_ref());
+    fn select_folder(&self, context: &Context, folder: &str) -> Result<(), Error> {
+        if self.session.lock().unwrap().is_none() {
+            let mut cfg = self.config.write().unwrap();
+            cfg.selected_folder = None;
+            cfg.selected_folder_needs_expunge = false;
+            bail!("select_folder: session is closed");
+        }
+
+        // if there is a new folder and the new folder is equal to the selected one, there's nothing to do.
+        // if there is _no_ new folder, we continue as we might want to expunge below.
+        if let Some(ref selected_folder) = self.config.read().unwrap().selected_folder {
+            if folder == selected_folder {
+                return Ok(());
+            }
+        }
+
+        // deselect existing folder, if needed (it's also done implicitly by SELECT, however, without EXPUNGE then)
+        let needs_expunge = { self.config.read().unwrap().selected_folder_needs_expunge };
+        if needs_expunge {
+            self.expunge_folder(context);
+            self.config.write().unwrap().selected_folder_needs_expunge = false;
+        }
+
+        // select new folder
+        if let Some(ref mut session) = &mut *self.session.lock().unwrap() {
+            match session.select(&folder) {
+                Ok(mailbox) => {
+                    let mut config = self.config.write().unwrap();
+                    config.selected_folder = Some(folder.to_string());
+                    config.selected_mailbox = Some(mailbox);
+                }
+                Err(err) => {
+                    self.config.write().unwrap().selected_folder = None;
+                    self.should_reconnect.store(true, Ordering::Relaxed);
+                    bail!("Cannot select folder: {}; {:?}.", folder, err);
+                }
+            }
+        } else {
+            unreachable!();
+        }
+
+        Ok(())
+    }
+
+    fn get_config_last_seen_uid(&self, context: &Context, folder: &str) -> (u32, u32) {
+        let key = format!("imap.mailbox.{}", folder);
         if let Some(entry) = context.sql.get_raw_config(context, &key) {
             // the entry has the format `imap.mailbox.<folder>=<uidvalidity>:<lastseenuid>`
             let mut parts = entry.split(':');
@@ -727,49 +720,25 @@ impl Imap {
         }
     }
 
-    fn fetch_from_single_folder<S: AsRef<str>>(&self, context: &Context, folder: S) -> usize {
-        if !self.is_connected() {
-            info!(
-                context,
-                "Cannot fetch from \"{}\" - not connected.",
-                folder.as_ref()
-            );
-
-            return 0;
-        }
-
-        if self.select_folder(context, Some(&folder)) == 0 {
-            info!(
-                context,
-                "Cannot select folder \"{}\" for fetching.",
-                folder.as_ref()
-            );
-
-            return 0;
-        }
 
+    fn 
+        
         // compare last seen UIDVALIDITY against the current one
-        let (mut uid_validity, mut last_seen_uid) = self.get_config_last_seen_uid(context, &folder);
+        let (last_uid_validity, last_seen_uid) = self.get_config_last_seen_uid(context, &folder);
+        let mailbox = self.config.read().unwrap().selected_mailbox.as_ref().expect("just selected");
 
-        let config = self.config.read().unwrap();
-        let mailbox = config.selected_mailbox.as_ref().expect("just selected");
+        ensure!(mailbox.uid_validity.is_some(),
+            "Cannot get UIDVALIDITY for folder \"{}\".", folder,);
 
-        if mailbox.uid_validity.is_none() {
-            error!(
-                context,
-                "Cannot get UIDVALIDITY for folder \"{}\".",
-                folder.as_ref(),
-            );
+        let mailbox = mailbox.unwrap();
+        let current_uid_validity = mailbox.uid_validity.unwrap_or_default();
 
-            return 0;
-        }
-
-        if mailbox.uid_validity.unwrap_or_default() != uid_validity {
-            // first time this folder is selected or UIDVALIDITY has changed, init lastseenuid and save it to config
+        if current_uid_validity != last_uid_validity {
+            // first time this folder is selected or UIDVALIDITY has changed, 
+            // init lastseenuid and save it to config
 
             if mailbox.exists == 0 {
-                info!(context, "Folder \"{}\" is empty.", folder.as_ref());
-
+                info!(context, "Folder \"{}\" is empty.", folder);
                 // set lastseenuid=0 for empty folders.
                 // id we do not do this here, we'll miss the first message
                 // as we will get in here again and fetch from lastseenuid+1 then
@@ -777,10 +746,10 @@ impl Imap {
                 self.set_config_last_seen_uid(
                     context,
                     &folder,
-                    mailbox.uid_validity.unwrap_or_default(),
+                    current_uid_validity,
                     0,
                 );
-                return 0;
+                return Ok(false);
             }
 
             let list = if let Some(ref mut session) = &mut *self.session.lock().unwrap() {
@@ -788,56 +757,57 @@ impl Imap {
                 let set = format!("{}", mailbox.exists);
                 match session.fetch(set, PREFETCH_FLAGS) {
                     Ok(list) => list,
-                    Err(_err) => {
+                    Err(err) => {
                         self.should_reconnect.store(true, Ordering::Relaxed);
-                        info!(
-                            context,
-                            "No result returned for folder \"{}\".",
-                            folder.as_ref()
-                        );
-
-                        return 0;
+                        bail!("IMAP FETCH {} {} failed on folder '{}': {}'", 
+                              set, PREFETCH_FLAGS, folder, err);
                     }
                 }
             } else {
-                return 0;
+                unreachable!();
             };
 
-            last_seen_uid = list[0].uid.unwrap_or_else(|| 0);
+            last_seen_uid = list[0].uid.unwrap_or_default();
 
             // if the UIDVALIDITY has _changed_, decrease lastseenuid by one to avoid gaps (well add 1 below
-            if uid_validity > 0 && last_seen_uid > 1 {
+            if last_uid_validity > 0 && last_seen_uid > 1 {
                 last_seen_uid -= 1;
             }
 
-            uid_validity = mailbox.uid_validity.unwrap_or_default();
             self.set_config_last_seen_uid(context, &folder, uid_validity, last_seen_uid);
             info!(
                 context,
                 "lastseenuid initialized to {} for {}@{}",
                 last_seen_uid,
-                folder.as_ref(),
+                folder,
                 uid_validity,
             );
+            Ok(true)
         }
 
+    fn fetch_from_single_folder(&self, context: &Context, folder: &str) -> Result<(), Error> {
+        self.select_folder(context, &folder)?;
+
+        if self.folder_is_uidvalid_and_empty(&self, context: &Context, folder: &str)? {
+            return  
+
         let mut read_cnt = 0;
         let mut read_errors = 0;
         let mut new_last_seen_uid = 0;
 
+        let set = format!("{}:*", last_seen_uid + 1);
         let list = if let Some(ref mut session) = &mut *self.session.lock().unwrap() {
             // fetch messages with larger UID than the last one seen
             // (`UID FETCH lastseenuid+1:*)`, see RFC 4549
-            let set = format!("{}:*", last_seen_uid + 1);
             match session.uid_fetch(set, PREFETCH_FLAGS) {
                 Ok(list) => list,
                 Err(err) => {
                     warn!(context, "failed to fetch uids: {}", err);
-                    return 0;
+                    bail!("failed to fetch uids: {}", err)
                 }
             }
         } else {
-            return 0;
+            unreachable!();
         };
 
         // go through all mails in folder (this is typically _fast_ as we already have the whole list)
@@ -848,14 +818,14 @@ impl Imap {
 
                 let message_id = prefetch_get_message_id(msg).unwrap_or_default();
 
-                if !precheck_imf(context, &message_id, folder.as_ref(), cur_uid) {
+                if !precheck_imf(context, &message_id, &folder, cur_uid) {
                     // check passed, go fetch the rest
                     if self.fetch_single_msg(context, &folder, cur_uid) == 0 {
                         info!(
                             context,
                             "Read error for message {} from \"{}\", trying over later.",
                             message_id,
-                            folder.as_ref()
+                            folder
                         );
 
                         read_errors += 1;
@@ -866,7 +836,7 @@ impl Imap {
                         context,
                         "Skipping message {} from \"{}\" by precheck.",
                         message_id,
-                        folder.as_ref(),
+                        folder
                     );
                 }
                 if cur_uid > new_last_seen_uid {
@@ -886,7 +856,7 @@ impl Imap {
                 context,
                 "{} mails read from \"{}\" with {} errors.",
                 read_cnt,
-                folder.as_ref(),
+                folder,
                 read_errors
             );
         } else {
@@ -894,30 +864,30 @@ impl Imap {
                 context,
                 "{} mails read from \"{}\".",
                 read_cnt,
-                folder.as_ref()
+                folder
             );
         }
 
-        read_cnt
+        Ok(read_cnt)
     }
 
-    fn set_config_last_seen_uid<S: AsRef<str>>(
+    fn set_config_last_seen_uid(
         &self,
         context: &Context,
-        folder: S,
+        folder: &str,
         uidvalidity: u32,
         lastseenuid: u32,
     ) {
-        let key = format!("imap.mailbox.{}", folder.as_ref());
+        let key = format!("imap.mailbox.{}", folder);
         let val = format!("{}:{}", uidvalidity, lastseenuid);
 
         context.sql.set_raw_config(context, &key, Some(&val)).ok();
     }
 
-    fn fetch_single_msg<S: AsRef<str>>(
+    fn fetch_single_msg(
         &self,
         context: &Context,
-        folder: S,
+        folder: &str,
         server_uid: u32,
     ) -> usize {
         // the function returns:
@@ -938,7 +908,7 @@ impl Imap {
                         context,
                         "Error on fetching message #{} from folder \"{}\"; retry={}; error={}.",
                         server_uid,
-                        folder.as_ref(),
+                        folder,
                         self.should_reconnect(),
                         err
                     );
@@ -954,7 +924,7 @@ impl Imap {
                 context,
                 "Message #{} does not exist in folder \"{}\".",
                 server_uid,
-                folder.as_ref()
+                folder,
             );
         } else {
             let msg = &msgs[0];
@@ -974,7 +944,7 @@ impl Imap {
             if !is_deleted && msg.body().is_some() {
                 let body = msg.body().unwrap_or_default();
                 unsafe {
-                    dc_receive_imf(context, &body, folder.as_ref(), server_uid, flags as u32);
+                    dc_receive_imf(context, &body, &folder, server_uid, flags as u32);
                 }
             }
         }
@@ -982,18 +952,16 @@ impl Imap {
         1
     }
 
-    pub fn idle(&self, context: &Context) {
+    pub fn idle(&self, context: &Context) -> Result<(), Error> {
         if !self.config.read().unwrap().can_idle {
-            return self.fake_idle(context);
+            self.fake_idle(context);
         }
 
-        self.setup_handle_if_needed(context);
+        self.setup_handle_if_needed(context)?;
 
         let watch_folder = self.config.read().unwrap().watch_folder.clone();
-        if self.select_folder(context, watch_folder.as_ref()) == 0 {
-            warn!(context, "IMAP-IDLE not setup.",);
-
-            return self.fake_idle(context);
+        if let Some(wfolder) = watch_folder {
+            self.select_folder(context, &wfolder)?;
         }
 
         let session = self.session.clone();
@@ -1087,6 +1055,7 @@ impl Imap {
         }
 
         *watch = false;
+        Ok(())
     }
 
     fn fake_idle(&self, context: &Context) {
@@ -1148,7 +1117,7 @@ impl Imap {
 
             let watch_folder = self.config.read().unwrap().watch_folder.clone();
             if let Some(watch_folder) = watch_folder {
-                if 0 != self.fetch_from_single_folder(context, watch_folder) {
+                if self.fetch_from_single_folder(context, &watch_folder).is_ok() {
                     do_fake_idle = false;
                 }
             }
@@ -1285,14 +1254,12 @@ impl Imap {
                 return Some(ImapResult::RetryLater);
             }
         }
-        if self.select_folder(context, Some(&folder)) == 0 {
-            warn!(
-                context,
-                "Cannot select folder {} for preparing IMAP operation", folder
-            );
-            Some(ImapResult::RetryLater)
-        } else {
-            None
+        match self.select_folder(context, &folder) {
+            Ok(()) => None,
+            Err(err) => { 
+                warn!(context, "Cannot select folder {}: {}", folder, err);
+                Some(ImapResult::RetryLater)
+            }
         }
     }
 
@@ -1498,28 +1465,17 @@ impl Imap {
         }
     }
 
-    pub fn empty_folder(&self, context: &Context, folder: &str) {
+    pub fn empty_folder(&self, context: &Context, folder: &str) -> Result<(), Error> {
         info!(context, "emptying folder {}", folder);
 
-        if folder.is_empty() || self.select_folder(context, Some(&folder)) == 0 {
-            warn!(context, "Cannot select folder '{}' for emptying", folder);
-            return;
-        }
+        self.select_folder(context, &folder)?;
 
-        if !self.add_flag_finalized_with_set(context, SELECT_ALL, "\\Deleted") {
-            warn!(context, "Cannot empty folder {}", folder);
-        } else {
-            // we now trigger expunge to actually delete messages
-            self.config.write().unwrap().selected_folder_needs_expunge = true;
-            if self.select_folder::<String>(context, None) == 0 {
-                warn!(
-                    context,
-                    "could not perform expunge on empty-marked folder {}", folder
-                );
-            } else {
-                emit_event!(context, Event::ImapFolderEmptied(folder.to_string()));
-            }
-        }
+        ensure!(self.add_flag_finalized_with_set(context, SELECT_ALL, "\\Deleted"),
+                "Could not set \\Deleted flags to empty {}", folder);
+
+        ensure!(self.expunge_folder(context), "Could not expunge");
+        emit_event!(context, Event::ImapFolderEmptied(folder.to_string()));
+        Ok(())
     }
 }
 

src/imex.rs

@@ -1,5 +1,5 @@
 use core::cmp::{max, min};
-use std::path::{Path, PathBuf};
+use std::path::Path;
 
 use num_traits::FromPrimitive;
 use rand::{thread_rng, Rng};
@@ -75,7 +75,7 @@ pub fn imex(context: &Context, what: ImexMode, param1: Option<impl AsRef<Path>>)
     job_add(context, Action::ImexImap, 0, param, 0);
 }
 
-/// Returns the filename of the backup if found, nullptr otherwise.
+/// Returns the filename of the backup found (otherwise an error)
 pub fn has_backup(context: &Context, dir_name: impl AsRef<Path>) -> Result<String> {
     let dir_name = dir_name.as_ref();
     let dir_iter = std::fs::read_dir(dir_name)?;
@@ -90,13 +90,15 @@ pub fn has_backup(context: &Context, dir_name: impl AsRef<Path>) -> Result<Strin
                 if name.starts_with("delta-chat") && name.ends_with(".bak") {
                     let sql = Sql::new();
                     if sql.open(context, &path, true) {
-                        let curr_backup_time =
-                            sql.get_raw_config_int(context, "backup_time")
-                                .unwrap_or_default() as u64;
+                        let curr_backup_time = sql
+                            .get_raw_config_int(context, "backup_time")
+                            .unwrap_or_default();
                         if curr_backup_time > newest_backup_time {
                             newest_backup_path = Some(path);
                             newest_backup_time = curr_backup_time;
                         }
+                        info!(context, "backup_time of {} is {}", name, curr_backup_time);
+                        sql.close(&context);
                     }
                 }
             }
@@ -105,7 +107,7 @@ pub fn has_backup(context: &Context, dir_name: impl AsRef<Path>) -> Result<Strin
     }
     match newest_backup_path {
         Some(path) => Ok(path.to_string_lossy().into_owned()),
-        None => bail!("no backup found"),
+        None => bail!("no backup found in {}", dir_name.display()),
     }
 }
 
@@ -483,10 +485,13 @@ fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
     // let dest_path_filename = dc_get_next_backup_file(context, dir, res);
     let now = time();
     let dest_path_filename = dc_get_next_backup_path(dir, now)?;
+    let dest_path_string = dest_path_filename.to_string_lossy().to_string();
 
     sql::housekeeping(context);
 
     sql::try_execute(context, &context.sql, "VACUUM;").ok();
+
+    // we close the database during the copy of the dbfile
     context.sql.close(context);
     info!(
         context,
@@ -496,38 +501,40 @@ fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
     );
     let copied = dc_copy_file(context, context.get_dbfile(), &dest_path_filename);
     context.sql.open(&context, &context.get_dbfile(), false);
+
     if !copied {
-        let s = dest_path_filename.to_string_lossy().to_string();
         bail!(
             "could not copy file from '{}' to '{}'",
             context.get_dbfile().display(),
-            s
+            dest_path_string
         );
     }
-    match add_files_to_export(context, &dest_path_filename) {
+    let dest_sql = Sql::new();
+    ensure!(
+        dest_sql.open(context, &dest_path_filename, false),
+        "could not open exported database {}",
+        dest_path_string
+    );
+    let res = match add_files_to_export(context, &dest_sql) {
         Err(err) => {
             dc_delete_file(context, &dest_path_filename);
             error!(context, "backup failed: {}", err);
             Err(err)
         }
         Ok(()) => {
-            context
-                .sql
-                .set_raw_config_int(context, "backup_time", now as i32)?;
+            dest_sql.set_raw_config_int(context, "backup_time", now as i32)?;
             context.call_cb(Event::ImexFileWritten(dest_path_filename.clone()));
             Ok(())
         }
-    }
+    };
+    dest_sql.close(context);
+
+    res
 }
 
-fn add_files_to_export(context: &Context, dest_path_filename: &PathBuf) -> Result<()> {
+fn add_files_to_export(context: &Context, sql: &Sql) -> Result<()> {
     // add all files as blobs to the database copy (this does not require
     // the source to be locked, neigher the destination as it is used only here)
-    let sql = Sql::new();
-    ensure!(
-        sql.open(context, &dest_path_filename, false),
-        "could not open db"
-    );
     if !sql.table_exists("backup_blobs") {
         sql::execute(
             context,

src/job.rs

@@ -291,19 +291,20 @@ impl Job {
     }
 
     #[allow(non_snake_case)]
-    fn do_DC_JOB_EMPTY_SERVER(&mut self, context: &Context) {
+    fn do_DC_JOB_EMPTY_SERVER(&mut self, context: &Context) -> Result<(), Error> {
         let inbox = context.inbox.read().unwrap();
         if self.foreign_id & DC_EMPTY_MVBOX > 0 {
             if let Some(mvbox_folder) = context
                 .sql
                 .get_raw_config(context, "configured_mvbox_folder")
             {
-                inbox.empty_folder(context, &mvbox_folder);
+                inbox.empty_folder(context, &mvbox_folder)?;
             }
         }
         if self.foreign_id & DC_EMPTY_INBOX > 0 {
-            inbox.empty_folder(context, "INBOX");
+            inbox.empty_folder(context, "INBOX")?;
         }
+        Ok(())
     }
 
     #[allow(non_snake_case)]
@@ -793,7 +794,14 @@ fn job_perform(context: &Context, thread: Thread, probe_network: bool) {
                     warn!(context, "Unknown job id found");
                 }
                 Action::SendMsgToSmtp => job.do_DC_JOB_SEND(context),
-                Action::EmptyServer => job.do_DC_JOB_EMPTY_SERVER(context),
+                Action::EmptyServer => {
+                    match job.do_DC_JOB_EMPTY_SERVER(context) {
+                        Ok(()) => {},
+                        Err(err) => {
+                            warn!(context, "emptying server folder(s) failed: {}", err);
+                        }
+                    }
+                }
                 Action::DeleteMsgOnImap => job.do_DC_JOB_DELETE_MSG_ON_IMAP(context),
                 Action::MarkseenMsgOnImap => job.do_DC_JOB_MARKSEEN_MSG_ON_IMAP(context),
                 Action::MarkseenMdnOnImap => job.do_DC_JOB_MARKSEEN_MDN_ON_IMAP(context),

src/location.rs

@@ -219,7 +219,7 @@ pub fn send_locations_to_chat(context: &Context, chat_id: u32, seconds: i64) {
             } else if 0 == seconds && is_sending_locations_before {
                 let stock_str =
                     context.stock_system_msg(StockMessage::MsgLocationDisabled, "", "", 0);
-                chat::add_device_msg(context, chat_id, stock_str);
+                chat::add_info_msg(context, chat_id, stock_str);
             }
             context.call_cb(Event::ChatModified(chat_id));
             if 0 != seconds {
@@ -492,7 +492,7 @@ pub fn save(
     chat_id: u32,
     contact_id: u32,
     locations: &[Location],
-    independent: i32,
+    independent: bool,
 ) -> Result<u32, Error> {
     ensure!(chat_id > DC_CHAT_ID_LAST_SPECIAL, "Invalid chat id");
     context.sql.prepare2(
@@ -507,7 +507,7 @@ pub fn save(
             for location in locations {
                 let exists = stmt_test.exists(params![location.timestamp, contact_id as i32])?;
 
-                if 0 != independent || !exists {
+                if independent || !exists {
                     stmt_insert.execute(params![
                         location.timestamp,
                         contact_id as i32,
@@ -651,7 +651,7 @@ pub fn job_do_DC_JOB_MAYBE_SEND_LOC_ENDED(context: &Context, job: &mut Job) {
                     params![chat_id as i32],
                 ).is_ok() {
                     let stock_str = context.stock_system_msg(StockMessage::MsgLocationDisabled, "", "", 0);
-                    chat::add_device_msg(context, chat_id, stock_str);
+                    chat::add_info_msg(context, chat_id, stock_str);
                     context.call_cb(Event::ChatModified(chat_id));
                 }
             }

src/message.rs

@@ -381,23 +381,10 @@ impl Message {
         self.timestamp_sort
     }
 
-    pub fn is_truncated(&self) -> bool {
-        if let Some(text) = &self.text {
-            return text.chars().count() > DC_MSG_TRUNCATE_THRESHOLD
-        }
-        false
-    }
-
-    pub fn get_text(&self, full_message: bool) -> Option<String> {
-        if full_message {
-            self.text
+    pub fn get_text(&self) -> Option<String> {
+        self.text
             .as_ref()
-            .map(|text| text.to_string())
-        } else {
-            self.text
-                .as_ref()
-                .map(|text| dc_truncate(text, DC_MSG_TRUNCATE_THRESHOLD, false).to_string())
-        }
+            .map(|text| dc_truncate(text, 30000, false).to_string())
     }
 
     pub fn get_filename(&self) -> Option<String> {
@@ -489,8 +476,8 @@ impl Message {
 
     pub fn is_info(&self) -> bool {
         let cmd = self.param.get_cmd();
-        self.from_id == DC_CONTACT_ID_DEVICE as libc::c_uint
-            || self.to_id == DC_CONTACT_ID_DEVICE as libc::c_uint
+        self.from_id == DC_CONTACT_ID_INFO as libc::c_uint
+            || self.to_id == DC_CONTACT_ID_INFO as libc::c_uint
             || cmd != SystemMessage::Unknown && cmd != SystemMessage::AutocryptSetupMessage
     }
 
@@ -727,7 +714,7 @@ pub fn get_msg_info(context: &Context, msg_id: MsgId) -> String {
         ret += "\n";
     }
 
-    if msg.from_id == DC_CONTACT_ID_DEVICE || msg.to_id == DC_CONTACT_ID_DEVICE {
+    if msg.from_id == DC_CONTACT_ID_INFO || msg.to_id == DC_CONTACT_ID_INFO {
         // device-internal message, no further details needed
         return ret;
     }

src/param.rs

@@ -76,6 +76,8 @@ pub enum Param {
     ProfileImage = b'i',
     // For Chats
     Selftalk = b'K',
+    // For Chats
+    Devicetalk = b'D',
     // For QR
     Auth = b's',
     // For QR

src/qr.rs

@@ -150,7 +150,7 @@ fn decode_openpgp(context: &Context, qr: &str) -> Lot {
             let (id, _) = chat::create_or_lookup_by_contact_id(context, lot.id, Blocked::Deaddrop)
                 .unwrap_or_default();
 
-            chat::add_device_msg(
+            chat::add_info_msg(
                 context,
                 id,
                 format!("{} verified.", peerstate.addr.unwrap_or_default()),

src/securejoin.rs

@@ -638,7 +638,7 @@ fn secure_connection_established(context: &Context, contact_chat_id: u32) {
         "?"
     };
     let msg = context.stock_string_repl_str(StockMessage::ContactVerified, addr);
-    chat::add_device_msg(context, contact_chat_id, msg);
+    chat::add_info_msg(context, contact_chat_id, msg);
     emit_event!(context, Event::ChatModified(contact_chat_id));
 }
 
@@ -654,7 +654,7 @@ fn could_not_establish_secure_connection(context: &Context, contact_chat_id: u32
         },
     );
 
-    chat::add_device_msg(context, contact_chat_id, &msg);
+    chat::add_info_msg(context, contact_chat_id, &msg);
     error!(context, "{} ({})", &msg, details);
 }
 
@@ -735,7 +735,7 @@ pub fn handle_degrade_event(context: &Context, peerstate: &Peerstate) -> Result<
             };
             let msg = context.stock_string_repl_str(StockMessage::ContactSetupChanged, peeraddr);
 
-            chat::add_device_msg(context, contact_chat_id, msg);
+            chat::add_info_msg(context, contact_chat_id, msg);
             emit_event!(context, Event::ChatModified(contact_chat_id));
         }
     }

src/sql.rs

@@ -92,8 +92,7 @@ impl Sql {
         self.start_stmt(sql.to_string());
         self.with_conn(|conn| {
             let stmt = conn.prepare(sql)?;
-            let res = g(stmt, conn)?;
-            Ok(res)
+            g(stmt, conn)
         })
     }
 
@@ -106,8 +105,7 @@ impl Sql {
             let stmt1 = conn.prepare(sql1)?;
             let stmt2 = conn.prepare(sql2)?;
 
-            let res = g(stmt1, stmt2, conn)?;
-            Ok(res)
+            g(stmt1, stmt2, conn)
         })
     }
 
@@ -385,8 +383,8 @@ fn open(
             )?;
             sql.execute(
                 "INSERT INTO contacts (id,name,origin) VALUES \
-                 (1,'self',262144), (2,'device',262144), (3,'rsvd',262144), \
-                 (4,'rsvd',262144), (5,'rsvd',262144), (6,'rsvd',262144), \
+                 (1,'self',262144), (2,'info',262144), (3,'rsvd',262144), \
+                 (4,'rsvd',262144), (5,'device',262144), (6,'rsvd',262144), \
                  (7,'rsvd',262144), (8,'rsvd',262144), (9,'rsvd',262144);",
                 params![],
             )?;

src/stock.rs

@@ -110,6 +110,8 @@ pub enum StockMessage {
     Location = 66,
     #[strum(props(fallback = "Sticker"))]
     Sticker = 67,
+    #[strum(props(fallback = "Device Messages"))]
+    DeviceMessages = 68,
 }
 
 impl StockMessage {