factor out imex tracking

CHANGELOG.md

@@ -1,19 +1,5 @@
 # Changelog 
 
-## 1.27.0
-
-- handle keys reliably on armv7 #1327
-
-
-## 1.26.0
-
-- change generated key type back to RSA as shipped versions
-  have problems to encrypt to Ed25519 keys
-
-- update rPGP to encrypt reliably to Ed25519 keys;
-  one of the next versions can finally use Ed25519 keys then
-
-
 ## 1.25.0
 
 - save traffic by downloading only messages that are really displayed #1236

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat"
-version = "1.27.0"
+version = "1.25.0"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"
 license = "MPL-2.0"
@@ -12,7 +12,7 @@ lto = true
 deltachat_derive = { path = "./deltachat_derive" }
 
 libc = "0.2.51"
-pgp = { version = "0.5.1", default-features = false } 
+pgp = { version = "0.4.0", default-features = false }
 hex = "0.4.0"
 sha2 = "0.8.0"
 rand = "0.7.0"
@@ -84,7 +84,7 @@ required-features = ["rustyline"]
 
 
 [features]
-default = ["nightly"]
+default = ["nightly", "ringbuf"]
 vendored = ["async-native-tls/vendored", "reqwest/native-tls-vendored", "async-smtp/native-tls-vendored"]
 nightly = ["pgp/nightly"]
-
+ringbuf = ["pgp/ringbuf"]

README.md

@@ -108,6 +108,7 @@ $ cargo test -- --ignored
 
 - `vendored`: When using Openssl for TLS, this bundles a vendored version.
 - `nightly`: Enable nightly only performance and security related features.
+- `ringbuf`: Enable the use of [`slice_deque`](https://github.com/gnzlbg/slice_deque) in pgp.
 
 [circle-shield]: https://img.shields.io/circleci/project/github/deltachat/deltachat-core-rust/master.svg?style=flat-square
 [circle]: https://circleci.com/gh/deltachat/deltachat-core-rust/

deltachat-ffi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat_ffi"
-version = "1.27.0"
+version = "1.25.0"
 description = "Deltachat FFI"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"
@@ -23,6 +23,7 @@ failure = "0.1.6"
 serde_json = "1.0"
 
 [features]
-default = ["vendored", "nightly"]
+default = ["vendored", "nightly", "ringbuf"]
 vendored = ["deltachat/vendored"]
 nightly = ["deltachat/nightly"]
+ringbuf = ["deltachat/ringbuf"]

python/src/deltachat/account.py

@@ -38,7 +38,7 @@ class Account(object):
             lib.dc_context_new(lib.py_dc_callback, ffi.NULL, as_dc_charpointer(os_name)),
             _destroy_dc_context,
         )
-        self._evlogger = EventLogger(self, logid, debug)
+        self._evlogger = EventLogger(self._dc_context, logid, debug)
         self._threads = IOThreads(self._dc_context, self._evlogger._log_event)
 
         # register event call back and initialize plugin system
@@ -386,7 +386,15 @@ class Account(object):
             lib.dc_imex(self._dc_context, imex_cmd, as_dc_charpointer(path), ffi.NULL)
             if not self._threads.is_started():
                 lib.dc_perform_imap_jobs(self._dc_context)
-            return imex_tracker.wait_finish()
+            files_written = []
+            while True:
+                ev = imex_tracker.get()
+                if isinstance(ev, str):
+                    files_written.append(ev)
+                elif isinstance(ev, bool):
+                    if not ev:
+                        raise ValueError("export failed, exp-files: {}".format(files_written))
+                    return files_written
 
     def import_self_keys(self, path):
         """ Import private keys found in the `path` directory.
@@ -408,7 +416,8 @@ class Account(object):
             lib.dc_imex(self._dc_context, imex_cmd, as_dc_charpointer(path), ffi.NULL)
             if not self._threads.is_started():
                 lib.dc_perform_imap_jobs(self._dc_context)
-            imex_tracker.wait_finish()
+            if not imex_tracker.get():
+                raise ValueError("import from path '{}' failed".format(path))
 
     def initiate_key_transfer(self):
         """return setup code after a Autocrypt setup message
@@ -511,7 +520,7 @@ class Account(object):
             deltachat.clear_context_callback(self._dc_context)
             del self._dc_context
             atexit.unregister(self.shutdown)
-        self.pluggy.unregister(self._evlogger)
+        self.pluggy.unregister(self)
 
     def set_location(self, latitude=0.0, longitude=0.0, accuracy=0.0):
         """set a new location. It effects all chats where we currently
@@ -533,6 +542,16 @@ class ImexTracker:
         self._imex_events = Queue()
         self.account = account
 
+    @hookimpl
+    def process_low_level_event(self, account, event_name, data1, data2):
+        # there could be multiple accounts instantiated
+        if self.account is not account:
+            return
+        method = getattr(self, "on_" + event_name.lower(), None)
+        if method is not None:
+            print("*** on_ -> ", event_name.lower())
+            method(data1, data2)
+
     def __enter__(self):
         self.account.pluggy.register(self)
         return self
@@ -540,27 +559,17 @@ class ImexTracker:
     def __exit__(self, *args):
         self.account.pluggy.unregister(self)
 
-    @hookimpl
-    def process_low_level_event(self, account, event_name, data1, data2):
-        # there could be multiple accounts instantiated
-        if self.account is not account:
-            return
-        if event_name == "DC_EVENT_IMEX_PROGRESS":
-            self._imex_events.put(data1)
-        elif event_name == "DC_EVENT_IMEX_FILE_WRITTEN":
-            self._imex_events.put(data1)
+    def get(self, timeout=60):
+        return self._imex_events.get(timeout=timeout)
 
-    def wait_finish(self, progress_timeout=60):
-        """ Return list of written files, raise ValueError if ExportFailed. """
-        files_written = []
-        while True:
-            ev = self._imex_events.get(timeout=progress_timeout)
-            if isinstance(ev, str):
-                files_written.append(ev)
-            elif ev == 0:
-                raise ValueError("export failed, exp-files: {}".format(files_written))
-            elif ev == 1000:
-                return files_written
+    def on_dc_event_imex_progress(self, data1, data2):
+        if data1 == 1000:
+            self._imex_events.put(True)
+        elif data1 == 0:
+            self._imex_events.put(False)
+
+    def on_dc_event_imex_file_written(self, data1, data2):
+        self._imex_events.put(data1)
 
 
 class IOThreads:

python/src/deltachat/eventlogger.py

@@ -8,28 +8,27 @@ from .hookspec import hookimpl
 class EventLogger:
     _loglock = threading.RLock()
 
-    def __init__(self, account, logid=None, debug=True):
-        self.account = account
+    def __init__(self, dc_context, logid=None, debug=True):
+        self._dc_context = dc_context
         self._event_queue = Queue()
         self._debug = debug
         if logid is None:
-            logid = str(self.account._dc_context).strip(">").split()[-1]
+            logid = str(self._dc_context).strip(">").split()[-1]
         self.logid = logid
         self._timeout = None
         self.init_time = time.time()
 
     @hookimpl
-    def process_low_level_event(self, account, event_name, data1, data2):
-        if self.account == account:
-            self._log_event(event_name, data1, data2)
-            self._event_queue.put((event_name, data1, data2))
+    def process_low_level_event(self, event_name, data1, data2):
+        self._log_event(event_name, data1, data2)
+        self._event_queue.put((event_name, data1, data2))
 
     def set_timeout(self, timeout):
         self._timeout = timeout
 
     def consume_events(self, check_error=True):
         while not self._event_queue.empty():
-            self.get(check_error=check_error)
+            self.get()
 
     def get(self, timeout=None, check_error=True):
         timeout = timeout or self._timeout

python/src/deltachat/hookspec.py

@@ -1,25 +0,0 @@
-""" Hooks for python bindings """
-
-import pluggy
-
-name = "deltachat"
-
-hookspec = pluggy.HookspecMarker(name)
-hookimpl = pluggy.HookimplMarker(name)
-_plugin_manager = None
-
-
-def get_plugin_manager():
-    global _plugin_manager
-    if _plugin_manager is None:
-        _plugin_manager = pluggy.PluginManager(name)
-        _plugin_manager.add_hookspecs(DeltaChatHookSpecs)
-    return _plugin_manager
-
-
-class DeltaChatHookSpecs:
-    """ Plugin Hook specifications for Python bindings to Delta Chat CFFI. """
-
-    @hookspec
-    def process_low_level_event(self, account, event_name, data1, data2):
-        """ process a CFFI low level events for a given account. """

python/tests/test_lowlevel.py

@@ -2,6 +2,7 @@ from __future__ import print_function
 from deltachat import capi, cutil, const, set_context_callback, clear_context_callback
 from deltachat.capi import ffi
 from deltachat.capi import lib
+from deltachat.account import EventLogger
 
 
 def test_empty_context():
@@ -17,13 +18,21 @@ def test_callback_None2int():
 
 
 def test_dc_close_events(tmpdir):
-    from deltachat.account import Account
+    ctx = ffi.gc(
+        capi.lib.dc_context_new(capi.lib.py_dc_callback, ffi.NULL, ffi.NULL),
+        lib.dc_context_unref,
+    )
+    evlog = EventLogger(ctx)
+    evlog.set_timeout(5)
+    set_context_callback(
+        ctx,
+        lambda ctx, evt_name, data1, data2: evlog(evt_name, data1, data2)
+    )
     p = tmpdir.join("hello.db")
-    ac1 = Account(p.strpath)
-    ac1.shutdown()
+    lib.dc_open(ctx, p.strpath.encode("ascii"), ffi.NULL)
+    capi.lib.dc_close(ctx)
 
     def find(info_string):
-        evlog = ac1._evlogger
         while 1:
             ev = evlog.get_matching("DC_EVENT_INFO", check_error=False)
             data2 = ev[2]

src/chatlist.rs

@@ -421,18 +421,4 @@ mod tests {
         let chats = Chatlist::try_load(&t.ctx, 0, Some("t-5678-b"), None).unwrap();
         assert_eq!(chats.len(), 1);
     }
-
-    #[test]
-    fn test_get_summary_unwrap() {
-        let t = dummy_context();
-        let chat_id1 = create_group_chat(&t.ctx, VerifiedStatus::Unverified, "a chat").unwrap();
-
-        let mut msg = Message::new(Viewtype::Text);
-        msg.set_text(Some("foo:\nbar \r\n test".to_string()));
-        chat_id1.set_draft(&t.ctx, Some(&mut msg));
-
-        let chats = Chatlist::try_load(&t.ctx, 0, None, None).unwrap();
-        let summary = chats.get_summary(&t.ctx, 0, None);
-        assert_eq!(summary.get_text2().unwrap(), "foo: bar test"); // the linebreak should be removed from summary
-    }
 }

src/contact.rs

@@ -118,7 +118,7 @@ pub enum Origin {
     Internal = 0x40000,
 
     /// address is in our address book
-    AddressBook = 0x80000,
+    AdressBook = 0x80000,
 
     /// set on Alice's side for contacts like Bob that have scanned the QR code offered by her. Only means the contact has once been established using the "securejoin" procedure in the past, getting the current key verification status requires calling dc_contact_is_verified() !
     SecurejoinInvited = 0x0100_0000,
@@ -497,18 +497,9 @@ impl Contact {
 
         for (name, addr) in split_address_book(addr_book.as_ref()).into_iter() {
             let name = normalize_name(name);
-            match Contact::add_or_lookup(context, name, addr, Origin::AddressBook) {
-                Err(err) => {
-                    warn!(
-                        context,
-                        "Failed to add address {} from address book: {}", addr, err
-                    );
-                }
-                Ok((_, modified)) => {
-                    if modified != Modifier::None {
-                        modify_cnt += 1
-                    }
-                }
+            let (_, modified) = Contact::add_or_lookup(context, name, addr, Origin::AdressBook)?;
+            if modified != Modifier::None {
+                modify_cnt += 1
             }
         }
         if modify_cnt > 0 {
@@ -1238,7 +1229,6 @@ mod tests {
         let book = concat!(
             "  Name one  \n one@eins.org \n",
             "Name two\ntwo@deux.net\n",
-            "Invalid\n+1234567890\n", // invalid, should be ignored
             "\nthree@drei.sam\n",
             "Name two\ntwo@deux.net\n" // should not be added again
         );

src/dc_receive_imf.rs

@@ -1464,7 +1464,7 @@ fn is_known_rfc724_mid_in_list(context: &Context, mid_list: &str) -> bool {
         return false;
     }
 
-    if let Ok(ids) = mailparse::msgidparse(mid_list) {
+    if let Ok(ids) = mailparse::addrparse(mid_list) {
         for id in ids.iter() {
             if is_known_rfc724_mid(context, id) {
                 return true;
@@ -1476,7 +1476,8 @@ fn is_known_rfc724_mid_in_list(context: &Context, mid_list: &str) -> bool {
 }
 
 /// Check if a message is a reply to a known message (messenger or non-messenger).
-fn is_known_rfc724_mid(context: &Context, rfc724_mid: &str) -> bool {
+fn is_known_rfc724_mid(context: &Context, rfc724_mid: &mailparse::MailAddr) -> bool {
+    let addr = extract_single_from_addr(rfc724_mid);
     context
         .sql
         .exists(
@@ -1484,7 +1485,7 @@ fn is_known_rfc724_mid(context: &Context, rfc724_mid: &str) -> bool {
              LEFT JOIN chats c ON m.chat_id=c.id  \
              WHERE m.rfc724_mid=?  \
              AND m.chat_id>9 AND c.blocked=0;",
-            params![rfc724_mid],
+            params![addr],
         )
         .unwrap_or_default()
 }
@@ -1511,7 +1512,7 @@ fn is_reply_to_messenger_message(context: &Context, mime_parser: &MimeMessage) -
 }
 
 pub(crate) fn is_msgrmsg_rfc724_mid_in_list(context: &Context, mid_list: &str) -> bool {
-    if let Ok(ids) = mailparse::msgidparse(mid_list) {
+    if let Ok(ids) = mailparse::addrparse(mid_list) {
         for id in ids.iter() {
             if is_msgrmsg_rfc724_mid(context, id) {
                 return true;
@@ -1521,13 +1522,21 @@ pub(crate) fn is_msgrmsg_rfc724_mid_in_list(context: &Context, mid_list: &str) -
     false
 }
 
+fn extract_single_from_addr(addr: &mailparse::MailAddr) -> &String {
+    match addr {
+        mailparse::MailAddr::Group(infos) => &infos.addrs[0].addr,
+        mailparse::MailAddr::Single(info) => &info.addr,
+    }
+}
+
 /// Check if a message is a reply to any messenger message.
-fn is_msgrmsg_rfc724_mid(context: &Context, rfc724_mid: &str) -> bool {
+fn is_msgrmsg_rfc724_mid(context: &Context, rfc724_mid: &mailparse::MailAddr) -> bool {
+    let addr = extract_single_from_addr(rfc724_mid);
     context
         .sql
         .exists(
             "SELECT id FROM msgs  WHERE rfc724_mid=?  AND msgrmsg!=0  AND chat_id>9;",
-            params![rfc724_mid],
+            params![addr],
         )
         .unwrap_or_default()
 }

src/dc_tools.rs

@@ -19,10 +19,10 @@ pub(crate) fn dc_exactly_one_bit_set(v: i32) -> bool {
     0 != v && 0 == v & (v - 1)
 }
 
-/// Shortens a string to a specified length and adds "[...]" to the
-/// end of the shortened string.
-pub(crate) fn dc_truncate(buf: &str, approx_chars: usize) -> Cow<str> {
-    let ellipse = "[...]";
+/// Shortens a string to a specified length and adds "..." or "[...]" to the end of
+/// the shortened string.
+pub(crate) fn dc_truncate(buf: &str, approx_chars: usize, do_unwrap: bool) -> Cow<str> {
+    let ellipse = if do_unwrap { "..." } else { "[...]" };
 
     let count = buf.chars().count();
     if approx_chars > 0 && count > approx_chars + ellipse.len() {
@@ -538,42 +538,54 @@ mod tests {
     #[test]
     fn test_dc_truncate_1() {
         let s = "this is a little test string";
-        assert_eq!(dc_truncate(s, 16), "this is a [...]");
+        assert_eq!(dc_truncate(s, 16, false), "this is a [...]");
+        assert_eq!(dc_truncate(s, 16, true), "this is a ...");
     }
 
     #[test]
     fn test_dc_truncate_2() {
-        assert_eq!(dc_truncate("1234", 2), "1234");
+        assert_eq!(dc_truncate("1234", 2, false), "1234");
+        assert_eq!(dc_truncate("1234", 2, true), "1234");
     }
 
     #[test]
     fn test_dc_truncate_3() {
-        assert_eq!(dc_truncate("1234567", 1), "1[...]");
+        assert_eq!(dc_truncate("1234567", 1, false), "1[...]");
+        assert_eq!(dc_truncate("1234567", 1, true), "1...");
     }
 
     #[test]
     fn test_dc_truncate_4() {
-        assert_eq!(dc_truncate("123456", 4), "123456");
+        assert_eq!(dc_truncate("123456", 4, false), "123456");
+        assert_eq!(dc_truncate("123456", 4, true), "123456");
     }
 
     #[test]
     fn test_dc_truncate_edge() {
-        assert_eq!(dc_truncate("", 4), "");
+        assert_eq!(dc_truncate("", 4, false), "");
+        assert_eq!(dc_truncate("", 4, true), "");
 
-        assert_eq!(dc_truncate("\n  hello \n world", 4), "\n  [...]");
+        assert_eq!(dc_truncate("\n  hello \n world", 4, false), "\n  [...]");
+        assert_eq!(dc_truncate("\n  hello \n world", 4, true), "\n  ...");
 
-        assert_eq!(dc_truncate("𐠈0Aᝮa𫝀®!ꫛa¡0A𐢧00𐹠®A  丽ⷐએ", 1), "𐠈[...]");
         assert_eq!(
-            dc_truncate("𐠈0Aᝮa𫝀®!ꫛa¡0A𐢧00𐹠®A  丽ⷐએ", 0),
+            dc_truncate("𐠈0Aᝮa𫝀®!ꫛa¡0A𐢧00𐹠®A  丽ⷐએ", 1, false),
+            "𐠈[...]"
+        );
+        assert_eq!(
+            dc_truncate("𐠈0Aᝮa𫝀®!ꫛa¡0A𐢧00𐹠®A  丽ⷐએ", 0, false),
             "𐠈0Aᝮa𫝀®!ꫛa¡0A𐢧00𐹠®A  丽ⷐએ"
         );
 
         // 9 characters, so no truncation
-        assert_eq!(dc_truncate("𑒀ὐ￠🜀\u{1e01b}A a🟠", 6), "𑒀ὐ￠🜀\u{1e01b}A a🟠",);
+        assert_eq!(
+            dc_truncate("𑒀ὐ￠🜀\u{1e01b}A a🟠", 6, false),
+            "𑒀ὐ￠🜀\u{1e01b}A a🟠",
+        );
 
         // 12 characters, truncation
         assert_eq!(
-            dc_truncate("𑒀ὐ￠🜀\u{1e01b}A a🟠bcd", 6),
+            dc_truncate("𑒀ὐ￠🜀\u{1e01b}A a🟠bcd", 6, false),
             "𑒀ὐ￠🜀\u{1e01b}A[...]",
         );
     }
@@ -689,10 +701,11 @@ mod tests {
         #[test]
         fn test_dc_truncate(
             buf: String,
-            approx_chars in 0..10000usize
+            approx_chars in 0..10000usize,
+            do_unwrap: bool,
         ) {
-            let res = dc_truncate(&buf, approx_chars);
-            let el_len = 5;
+            let res = dc_truncate(&buf, approx_chars, do_unwrap);
+            let el_len = if do_unwrap { 3 } else { 5 };
             let l = res.chars().count();
             if approx_chars > 0 {
                 assert!(
@@ -706,7 +719,11 @@ mod tests {
 
             if approx_chars > 0 && buf.chars().count() > approx_chars + el_len {
                 let l = res.len();
-                assert_eq!(&res[l-5..l], "[...]", "missing ellipsis in {}", &res);
+                if do_unwrap {
+                    assert_eq!(&res[l-3..l], "...", "missing ellipsis in {}", &res);
+                } else {
+                    assert_eq!(&res[l-5..l], "[...]", "missing ellipsis in {}", &res);
+                }
             }
         }
     }

src/imap/mod.rs

@@ -1306,6 +1306,17 @@ fn precheck_imf(context: &Context, rfc724_mid: &str, server_folder: &str, server
     }
 }
 
+fn parse_message_id(value: &str) -> crate::error::Result<String> {
+    let addrs = mailparse::addrparse(value)
+        .map_err(|err| format_err!("failed to parse message id {:?}", err))?;
+
+    if let Some(info) = addrs.extract_single_info() {
+        return Ok(info.addr);
+    }
+
+    bail!("could not parse message_id: {}", value);
+}
+
 fn get_fetch_headers(prefetch_msg: &Fetch) -> Result<Vec<mailparse::MailHeader>> {
     let header_bytes = match prefetch_msg.header() {
         Some(header_bytes) => header_bytes,
@@ -1317,7 +1328,7 @@ fn get_fetch_headers(prefetch_msg: &Fetch) -> Result<Vec<mailparse::MailHeader>>
 
 fn prefetch_get_message_id(headers: &[mailparse::MailHeader]) -> Result<String> {
     if let Some(message_id) = headers.get_header_value(HeaderDef::MessageId)? {
-        Ok(crate::mimeparser::parse_message_id(&message_id)?)
+        Ok(parse_message_id(&message_id)?)
     } else {
         Err(Error::Other("prefetch: No message ID found".to_string()))
     }
@@ -1373,3 +1384,20 @@ fn prefetch_should_download(
     let show = show && !blocked_contact;
     Ok(show)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_message_id() {
+        assert_eq!(
+            parse_message_id("Mr.PRUe8HJBoaO.3whNvLCMFU0@testrun.org").unwrap(),
+            "Mr.PRUe8HJBoaO.3whNvLCMFU0@testrun.org"
+        );
+        assert_eq!(
+            parse_message_id("<Mr.PRUe8HJBoaO.3whNvLCMFU0@testrun.org>").unwrap(),
+            "Mr.PRUe8HJBoaO.3whNvLCMFU0@testrun.org"
+        );
+    }
+}

src/message.rs

@@ -4,7 +4,6 @@ use std::path::{Path, PathBuf};
 
 use deltachat_derive::{FromSql, ToSql};
 use failure::Fail;
-use lazy_static::lazy_static;
 use serde::{Deserialize, Serialize};
 
 use crate::chat::{self, Chat, ChatId};
@@ -22,10 +21,6 @@ use crate::pgp::*;
 use crate::sql;
 use crate::stock::StockMessage;
 
-lazy_static! {
-    static ref UNWRAP_RE: regex::Regex = regex::Regex::new(r"\s+").unwrap();
-}
-
 // In practice, the user additionally cuts the string themselves
 // pixel-accurate.
 const SUMMARY_CHARACTERS: usize = 160;
@@ -443,7 +438,7 @@ impl Message {
     pub fn get_text(&self) -> Option<String> {
         self.text
             .as_ref()
-            .map(|text| dc_truncate(text, 30000).to_string())
+            .map(|text| dc_truncate(text, 30000, false).to_string())
     }
 
     pub fn get_filename(&self) -> Option<String> {
@@ -814,7 +809,7 @@ pub fn get_msg_info(context: &Context, msg_id: MsgId) -> String {
         return ret;
     }
     let rawtxt = rawtxt.unwrap_or_default();
-    let rawtxt = dc_truncate(rawtxt.trim(), 100_000);
+    let rawtxt = dc_truncate(rawtxt.trim(), 100_000, false);
 
     let fts = dc_timestamp_to_str(msg.get_timestamp());
     ret += &format!("Sent: {}", fts);
@@ -1146,20 +1141,18 @@ pub fn get_summarytext_by_raw(
         return prefix;
     }
 
-    let summary = if let Some(text) = text {
+    if let Some(text) = text {
         if text.as_ref().is_empty() {
             prefix
         } else if prefix.is_empty() {
-            dc_truncate(text.as_ref(), approx_characters).to_string()
+            dc_truncate(text.as_ref(), approx_characters, true).to_string()
         } else {
             let tmp = format!("{} – {}", prefix, text.as_ref());
-            dc_truncate(&tmp, approx_characters).to_string()
+            dc_truncate(&tmp, approx_characters, true).to_string()
         }
     } else {
         prefix
-    };
-
-    UNWRAP_RE.replace_all(&summary, " ").to_string()
+    }
 }
 
 // as we do not cut inside words, this results in about 32-42 characters.

src/mimeparser.rs

@@ -741,7 +741,7 @@ impl MimeMessage {
 
     pub fn get_rfc724_mid(&self) -> Option<String> {
         self.get(HeaderDef::MessageId)
-            .and_then(|msgid| parse_message_id(msgid).ok())
+            .and_then(|msgid| parse_message_id(msgid))
     }
 
     fn merge_headers(headers: &mut HashMap<String, String>, fields: &[mailparse::MailHeader<'_>]) {
@@ -779,16 +779,14 @@ impl MimeMessage {
                 .get_header_value(HeaderDef::OriginalMessageId)
                 .ok()
                 .flatten()
-                .and_then(|v| parse_message_id(&v).ok())
+                .and_then(|v| parse_message_id(&v))
             {
                 let additional_message_ids = report_fields
                     .get_header_value(HeaderDef::AdditionalMessageIds)
                     .ok()
                     .flatten()
                     .map_or_else(Vec::new, |v| {
-                        v.split(' ')
-                            .filter_map(|s| parse_message_id(s).ok())
-                            .collect()
+                        v.split(' ').filter_map(parse_message_id).collect()
                     });
 
                 return Ok(Some(Report {
@@ -911,20 +909,14 @@ pub(crate) struct Report {
     additional_message_ids: Vec<String>,
 }
 
-pub(crate) fn parse_message_id(value: &str) -> crate::error::Result<String> {
-    let ids = mailparse::msgidparse(value)
-        .map_err(|err| format_err!("failed to parse message id {:?}", err))?;
-
-    if ids.len() == 1 {
-        let id = &ids[0];
-        if id.starts_with('<') && id.ends_with('>') {
-            Ok(id.chars().skip(1).take(id.len() - 2).collect())
-        } else {
-            bail!("message-ID {} is not enclosed in < and >", value);
+fn parse_message_id(field: &str) -> Option<String> {
+    if let Ok(addrs) = mailparse::addrparse(field) {
+        // Assume the message id is a single id in the form of <id>
+        if let mailparse::MailAddr::Single(mailparse::SingleInfo { ref addr, .. }) = addrs[0] {
+            return Some(addr.clone());
         }
-    } else {
-        bail!("could not parse message_id: {}", value);
     }
+    None
 }
 
 fn is_known(key: &str) -> bool {

src/pgp.rs

@@ -153,8 +153,8 @@ pub(crate) fn create_keypair(
     keygen_type: KeyGenType,
 ) -> std::result::Result<KeyPair, PgpKeygenError> {
     let (secret_key_type, public_key_type) = match keygen_type {
-        KeyGenType::Rsa2048 | KeyGenType::Default => (PgpKeyType::Rsa(2048), PgpKeyType::Rsa(2048)),
-        KeyGenType::Ed25519 => (PgpKeyType::EdDSA, PgpKeyType::ECDH),
+        KeyGenType::Rsa2048 => (PgpKeyType::Rsa(2048), PgpKeyType::Rsa(2048)),
+        KeyGenType::Ed25519 | KeyGenType::Default => (PgpKeyType::EdDSA, PgpKeyType::ECDH),
     };
 
     let user_id = format!("<{}>", addr);

src/provider/data.rs

@@ -22,9 +22,9 @@ lazy_static::lazy_static! {
 
     // aol.md: aol.com
     static ref P_AOL: Provider = Provider {
-        status: Status::PREPARATION,
-        before_login_hint: "To log in to AOL with Delta Chat, you need to set up an app password in the AOL web interface.",
-        after_login_hint: "",
+        status: Status::BROKEN,
+        before_login_hint: "You can't use Delta Chat to login to AOL.",
+        after_login_hint: "Seems like you logged in anyway, congratulations! 🎉 Feel free to tell us at https://github.com/deltachat/provider-db/issues that AOL works again.",
         overview_page: "https://providers.delta.chat/aol",
         server: vec![
         ],