remove one attr from mimeparser

run lint without installing the package
allow to use a different buildhost :)
2026-04-03 14:02:10 +03:00 · 2019-12-07 22:41:43 +01:00 · 2019-12-07 21:44:34 +01:00 · 2019-12-07 21:44:34 +01:00 · 2019-12-07 21:44:34 +01:00 · 2019-12-07 21:44:34 +01:00
34 changed files with 817 additions and 589 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,23 @@
 # Changelog 

-## 1.0.0-beta.10 (pending)
+## next (pending)
+
+- restructured (but not change) imap idle handling into own file. cc @link2xt
+
+## 1.0.0-beta.12
+
+- fix python bindings to use core for copying attachments to blobdir
+  and fix core to actually do it. @hpk42
+
+## 1.0.0-beta.11
+
+- trigger reconnect more often on imap error states.  Should fix an 
+  issue observed when trying to empty a folder.  @hpk42
+
+- un-split qr tests: we fixed qr-securejoin protocol flakyness 
+  last weeks. @hpk42
+
+## 1.0.0-beta.10

 - fix grpid-determination from in-reply-to and references headers. @hpk42

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -607,7 +607,7 @@ dependencies = [

 [[package]]
 name = "deltachat"
-version = "1.0.0-beta.10"
+version = "1.0.0-beta.12"
 dependencies = [
 "async-imap 0.1.1 (git+https://github.com/async-email/async-imap)",
 "async-std 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -683,9 +683,9 @@ dependencies = [

 [[package]]
 name = "deltachat_ffi"
-version = "1.0.0-beta.10"
+version = "1.0.0-beta.12"
 dependencies = [
- "deltachat 1.0.0-beta.10",
+ "deltachat 1.0.0-beta.12",
 "deltachat-provider-database 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "failure 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
 "human-panic 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -800,7 +800,7 @@ dependencies = [
 [[package]]
 name = "encoded-words"
 version = "0.1.0"
-source = "git+https://github.com/async-email/encoded-words#019e833f0c9ea7d4b0b693aab44e66d78d18f1d0"
+source = "git+https://github.com/async-email/encoded-words#2631c258183620f6d976abffabbfc2dcc697d793"
 dependencies = [
 "base64 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "charset 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat"
-version = "1.0.0-beta.10"
+version = "1.0.0-beta.12"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"
 license = "MPL"
--- a/assets/icon-device.png
+++ b/assets/icon-device.png
--- a/assets/icon-device.svg
+++ b/assets/icon-device.svg
@@ -7,42 +7,42 @@
   xmlns="http://www.w3.org/2000/svg"
   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   inkscape:version="0.92.4 5da689c313, 2019-01-14"
-   sodipodi:docname="icon-device.svg"
-   id="svg4344"
-   preserveAspectRatio="xMidYMid meet"
-   viewBox="0 0 45 45"
-   height="60"
-   width="60"
-   version="1.0"
-   inkscape:export-filename="/home/kerle/Workspace/deltachat-core-rust/assets/icon-device.png"
+   inkscape:export-ydpi="409.60001"
   inkscape:export-xdpi="409.60001"
-   inkscape:export-ydpi="409.60001">
+   inkscape:export-filename="/Users/bpetersen/projects/deltachat-core-rust/assets/icon-device.png"
+   version="1.0"
+   width="60"
+   height="60"
+   viewBox="0 0 45 45"
+   preserveAspectRatio="xMidYMid meet"
+   id="svg4344"
+   sodipodi:docname="icon-device.svg"
+   inkscape:version="1.0beta1 (32d4812, 2019-09-19)">
  <defs
     id="defs4348" />
  <sodipodi:namedview
-     inkscape:current-layer="svg4344"
-     inkscape:window-maximized="0"
-     inkscape:window-y="0"
-     inkscape:window-x="0"
-     inkscape:cy="28.471578"
-     inkscape:cx="28.03926"
-     inkscape:zoom="5.6"
-     units="px"
-     showgrid="false"
-     id="namedview4346"
-     inkscape:window-height="1019"
-     inkscape:window-width="1248"
-     inkscape:pageshadow="2"
-     inkscape:pageopacity="0"
-     guidetolerance="10"
-     gridtolerance="10"
-     objecttolerance="10"
-     borderopacity="1"
-     inkscape:document-rotation="0"
-     bordercolor="#666666"
+     inkscape:snap-global="false"
     pagecolor="#ffffff"
-     inkscape:snap-global="false" />
+     bordercolor="#666666"
+     inkscape:document-rotation="0"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="1600"
+     inkscape:window-height="1035"
+     id="namedview4346"
+     showgrid="false"
+     units="px"
+     inkscape:zoom="3.959798"
+     inkscape:cx="28.322498"
+     inkscape:cy="24.898474"
+     inkscape:window-x="45"
+     inkscape:window-y="23"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="svg4344" />
  <metadata
     id="metadata4336">
 Created by potrace 1.15, written by Peter Selinger 2001-2017
@@ -56,35 +56,28 @@ Created by potrace 1.15, written by Peter Selinger 2001-2017
  </cc:Work>
 </rdf:RDF>
 </metadata>
-  <circle
-     style="opacity:1;fill:#ffffff;fill-opacity:1;stroke-width:0.731071"
-     id="path859"
-     cx="22.5"
-     cy="22.5"
-     r="22.5" />
-  <circle
-     r="22.5"
-     cy="22.5"
-     cx="22.5"
-     id="path4917"
-     style="fill:#364e54;fill-opacity:0.67681497;stroke-width:0.58855402"
-     inkscape:export-xdpi="409"
-     inkscape:export-ydpi="409" />
+  <rect
+     y="-4.4408921e-16"
+     x="0"
+     height="45"
+     width="45"
+     id="rect860"
+     style="opacity:1;fill:#76868b;fill-opacity:1;stroke-width:0.819271" />
  <g
-     id="g4342"
-     transform="matrix(0.00255113,0,0,-0.00255113,5.586152,38.200477)"
-     style="fill:#ffffff;fill-opacity:1"
+     fill="#000000"
     stroke="none"
-     fill="#000000">
+     style="fill:#ffffff;fill-opacity:1"
+     transform="matrix(0.00255113,0,0,-0.00255113,5.586152,38.200477)"
+     id="g4342">
    <path
-       inkscape:connector-curvature="0"
-       id="path4338"
+       style="fill:#ffffff;fill-opacity:1"
       d="m 8175,12765 c -703,-114 -1248,-608 -1387,-1258 -17,-82 -21,-136 -22,-277 0,-202 15,-307 70,-470 149,-446 499,-733 1009,-828 142,-26 465,-23 619,6 691,131 1201,609 1328,1244 31,158 31,417 0,565 -114,533 -482,889 -1038,1004 -133,27 -448,35 -579,14 z"
-       style="fill:#ffffff;fill-opacity:1" />
+       id="path4338"
+       inkscape:connector-curvature="0" />
    <path
-       inkscape:connector-curvature="0"
-       id="path4340"
+       style="fill:#ffffff;fill-opacity:1"
       d="m 7070,9203 c -212,-20 -275,-27 -397,-48 -691,-117 -1400,-444 -2038,-940 -182,-142 -328,-270 -585,-517 -595,-571 -911,-974 -927,-1181 -6,-76 11,-120 69,-184 75,-80 159,-108 245,-79 109,37 263,181 632,595 539,606 774,826 1035,969 135,75 231,105 341,106 82,1 94,-2 138,-27 116,-68 161,-209 122,-376 -9,-36 -349,-868 -757,-1850 -407,-982 -785,-1892 -838,-2021 -287,-694 -513,-1389 -615,-1889 -70,-342 -90,-683 -52,-874 88,-440 381,-703 882,-792 124,-23 401,-30 562,-16 783,69 1674,461 2561,1125 796,596 1492,1354 1607,1751 43,146 -33,308 -168,360 -61,23 -100,15 -173,-36 -105,-74 -202,-170 -539,-529 -515,-551 -762,-783 -982,-927 -251,-164 -437,-186 -543,-65 -56,64 -74,131 -67,247 13,179 91,434 249,815 135,324 1588,4102 1646,4280 106,325 151,561 159,826 9,281 -22,463 -112,652 -58,122 -114,199 -211,292 -245,233 -582,343 -1044,338 -91,-1 -181,-3 -200,-5 z"
-       style="fill:#ffffff;fill-opacity:1" />
+       id="path4340"
+       inkscape:connector-curvature="0" />
  </g>
 </svg>
--- a/assets/icon-saved-messages.png
+++ b/assets/icon-saved-messages.png
--- a/assets/icon-saved-messages.svg
+++ b/assets/icon-saved-messages.svg
@@ -7,42 +7,42 @@
   xmlns="http://www.w3.org/2000/svg"
   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   inkscape:version="0.92.4 5da689c313, 2019-01-14"
-   sodipodi:docname="icon-saved-messages.svg"
-   id="svg4344"
-   preserveAspectRatio="xMidYMid meet"
-   viewBox="0 0 45 45"
-   height="60"
-   width="60"
-   version="1.0"
-   inkscape:export-filename="/home/kerle/test-icon.png"
+   inkscape:export-ydpi="409.60001"
   inkscape:export-xdpi="409.60001"
-   inkscape:export-ydpi="409.60001">
+   inkscape:export-filename="/home/kerle/test-icon.png"
+   version="1.0"
+   width="60"
+   height="60"
+   viewBox="0 0 45 45"
+   preserveAspectRatio="xMidYMid meet"
+   id="svg4344"
+   sodipodi:docname="icon-saved-messages.svg"
+   inkscape:version="1.0beta1 (32d4812, 2019-09-19)">
  <defs
     id="defs4348" />
  <sodipodi:namedview
-     inkscape:lockguides="false"
-     inkscape:current-layer="svg4344"
-     inkscape:window-maximized="0"
-     inkscape:window-y="130"
-     inkscape:window-x="89"
-     inkscape:cy="43.28624"
-     inkscape:cx="-21.066324"
-     inkscape:zoom="4"
-     units="px"
-     showgrid="false"
-     id="namedview4346"
-     inkscape:window-height="855"
-     inkscape:window-width="1395"
-     inkscape:pageshadow="2"
-     inkscape:pageopacity="0"
-     guidetolerance="10"
-     gridtolerance="10"
-     objecttolerance="10"
-     borderopacity="1"
-     inkscape:document-rotation="0"
+     pagecolor="#ffffff"
     bordercolor="#666666"
-     pagecolor="#ffffff" />
+     inkscape:document-rotation="0"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="1395"
+     inkscape:window-height="855"
+     id="namedview4346"
+     showgrid="false"
+     units="px"
+     inkscape:zoom="4"
+     inkscape:cx="29.308676"
+     inkscape:cy="49.03624"
+     inkscape:window-x="89"
+     inkscape:window-y="108"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="svg4344"
+     inkscape:lockguides="false" />
  <metadata
     id="metadata4336">
 Created by potrace 1.15, written by Peter Selinger 2001-2017
@@ -56,21 +56,16 @@ Created by potrace 1.15, written by Peter Selinger 2001-2017
  </cc:Work>
 </rdf:RDF>
 </metadata>
-  <circle
-     style="opacity:1;fill:#ffffff;fill-opacity:1;stroke-width:0.731071"
-     id="path859"
-     cx="22.5"
-     cy="22.5"
-     r="22.5" />
-  <circle
-     r="22.5"
-     cy="22.50293"
-     cx="22.5"
-     id="path4917"
-     style="fill:#87aade;fill-opacity:1;stroke-width:0.58855402" />
+  <rect
+     y="0"
+     x="0"
+     height="45"
+     width="45"
+     id="rect1420"
+     style="fill:#87aade;fill-opacity:1;stroke:none;stroke-width:0.968078" />
  <path
-     inkscape:connector-curvature="0"
-     d="M 13.5,7.5 V 39 h 0.08654 L 22.533801,29.370239 31.482419,39 h 0.01758 V 7.5 Z m 9.004056,4.108698 1.879508,4.876388 5.039514,0.359779 -3.879358,3.363728 1.227764,5.095749 -4.276893,-2.796643 -4.280949,2.788618 1.237229,-5.093073 -3.873949,-3.371754 5.040866,-0.350417 z"
+     id="rect846"
     style="fill:#ffffff;stroke-width:0.58409804"
-     id="rect846" />
+     d="M 13.5,7.5 V 39 h 0.08654 L 22.533801,29.370239 31.482419,39 h 0.01758 V 7.5 Z m 9.004056,4.108698 1.879508,4.876388 5.039514,0.359779 -3.879358,3.363728 1.227764,5.095749 -4.276893,-2.796643 -4.280949,2.788618 1.237229,-5.093073 -3.873949,-3.371754 5.040866,-0.350417 z"
+     inkscape:connector-curvature="0" />
 </svg>
--- a/ci_scripts/remote_tests_python.sh
+++ b/ci_scripts/remote_tests_python.sh
@@ -2,7 +2,7 @@

 export BRANCH=${CIRCLE_BRANCH:?branch to build}
 export REPONAME=${CIRCLE_PROJECT_REPONAME:?repository name}
-export SSHTARGET=ci@b1.delta.chat
+export SSHTARGET=${SSHTARGET-ci@b1.delta.chat}

 # we construct the BUILDDIR such that we can easily share the
 # CARGO_TARGET_DIR between runs ("..")
--- a/ci_scripts/remote_tests_rust.sh
+++ b/ci_scripts/remote_tests_rust.sh
@@ -2,7 +2,7 @@

 export BRANCH=${CIRCLE_BRANCH:?branch to build}
 export REPONAME=${CIRCLE_PROJECT_REPONAME:?repository name}
-export SSHTARGET=ci@b1.delta.chat
+export SSHTARGET=${SSHTARGET-ci@b1.delta.chat}

 # we construct the BUILDDIR such that we can easily share the
 # CARGO_TARGET_DIR between runs ("..")
--- a/deltachat-ffi/Cargo.toml
+++ b/deltachat-ffi/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat_ffi"
-version = "1.0.0-beta.10"
+version = "1.0.0-beta.12"
 description = "Deltachat FFI"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"
--- a/deltachat-ffi/deltachat.h
+++ b/deltachat-ffi/deltachat.h
@@ -994,11 +994,20 @@ uint32_t        dc_get_chat_id_by_contact_id (dc_context_t* context, uint32_t co
 *
 * Example:
 * ~~~
+ * char* blobdir = dc_get_blobdir(context);
+ * char* file_to_send = mprintf("%s/%s", blobdir, "send.mp4")
+ *
 * dc_msg_t* msg = dc_msg_new(context, DC_MSG_VIDEO);
- * dc_msg_set_file(msg, "/file/to/send.mp4", NULL);
+ * dc_msg_set_file(msg, file_to_send, NULL);
 * dc_prepare_msg(context, chat_id, msg);
- * // ... after /file/to/send.mp4 is ready:
+ *
+ * // ... create the file ...
+ *
 * dc_send_msg(context, chat_id, msg);
+ *
+ * dc_msg_unref(msg);
+ * free(file_to_send);
+ * dc_str_unref(file_to_send);
 * ~~~
 *
 * @memberof dc_context_t
@@ -1024,8 +1033,11 @@ uint32_t        dc_prepare_msg               (dc_context_t* context, uint32_t ch
 * Example:
 * ~~~
 * dc_msg_t* msg = dc_msg_new(context, DC_MSG_IMAGE);
+ *
 * dc_msg_set_file(msg, "/file/to/send.jpg", NULL);
 * dc_send_msg(context, chat_id, msg);
+ *
+ * dc_msg_unref(msg);
 * ~~~
 *
 * @memberof dc_context_t
@@ -1134,6 +1146,9 @@ void            dc_set_draft                 (dc_context_t* context, uint32_t ch
 *     // add a changelog
 *     dc_add_device_msg(context, "update-123", changelog_msg);
 * }
+ *
+ * dc_msg_unref(changelog_msg);
+ * dc_msg_unref(welome_msg);
 * ~~~
 */
 uint32_t        dc_add_device_msg            (dc_context_t* context, const char* label, dc_msg_t* msg);
@@ -1947,7 +1962,7 @@ void            dc_imex                      (dc_context_t* context, int what, c
 *         }
 *         while (!configure_succeeded())
 *     }
- *     free(file);
+ *     dc_str_unref(file);
 * }
 * ~~~
 *
--- a/python/src/deltachat/message.py
+++ b/python/src/deltachat/message.py
@@ -1,7 +1,6 @@
 """ The Message object. """

 import os
-import shutil
 from . import props
 from .cutil import from_dc_charpointer, as_dc_charpointer
 from .capi import lib, ffi
@@ -70,19 +69,6 @@ class Message(object):
        mtype = ffi.NULL if mime_type is None else as_dc_charpointer(mime_type)
        if not os.path.exists(path):
            raise ValueError("path does not exist: {!r}".format(path))
-        blobdir = self.account.get_blobdir()
-        if not path.startswith(blobdir):
-            for i in range(50):
-                ext = "" if i == 0 else "-" + str(i)
-                dest = os.path.join(blobdir, os.path.basename(path) + ext)
-                if os.path.exists(dest):
-                    continue
-                shutil.copyfile(path, dest)
-                break
-            else:
-                raise ValueError("could not create blobdir-path for {}".format(path))
-            path = dest
-        assert path.startswith(blobdir), path
        lib.dc_msg_set_file(self._dc_msg, as_dc_charpointer(path), mtype)

    @props.with_doc
--- a/python/tests/test_account.py
+++ b/python/tests/test_account.py
@@ -442,30 +442,63 @@ class TestOnlineAccount:
        assert self_addr not in ev[2]
        ev = ac1._evlogger.get_matching("DC_EVENT_DELETED_BLOB_FILE")

-    def test_prepare_file_with_unicode(self, acfactory, lp):
+    def test_send_file_twice_unicode_filename_mangling(self, tmpdir, acfactory, lp):
        ac1, ac2 = acfactory.get_two_online_accounts()
        chat = self.get_chat(ac1, ac2)

-        lp.sec("ac1: prepare and send attachment + text to ac2")
-        blobdir = ac1.get_blobdir()
-        basename = "somedäüta.txt"
-        p = os.path.join(blobdir, basename)
+        basename = "somedäüta.html.zip"
+        p = os.path.join(tmpdir.strpath, basename)
        with open(p, "w") as f:
            f.write("some data")
-        msg = Message.new_empty(ac1, "file")
-        msg.set_text("hello ä world")
-        msg.set_file(p)
-        message = chat.prepare_message(msg)
-        assert message.is_out_preparing()
-        assert message.text == "hello ä world"
-        chat.send_prepared(message)
+
+        def send_and_receive_message():
+            lp.sec("ac1: prepare and send attachment + text to ac2")
+            msg1 = Message.new_empty(ac1, "file")
+            msg1.set_text("withfile")
+            msg1.set_file(p)
+            message = chat.prepare_message(msg1)
+            assert message.is_out_preparing()
+            assert message.text == "withfile"
+            chat.send_prepared(message)
+
+            lp.sec("ac2: receive message")
+            ev = ac2._evlogger.get_matching("DC_EVENT_INCOMING_MSG|DC_EVENT_MSGS_CHANGED")
+            assert ev[2] > const.DC_CHAT_ID_LAST_SPECIAL
+            return ac2.get_message_by_id(ev[2])
+
+        msg = send_and_receive_message()
+        assert msg.text == "withfile"
+        assert open(msg.filename).read() == "some data"
+        assert msg.filename.endswith(basename)
+
+        msg2 = send_and_receive_message()
+        assert msg2.text == "withfile"
+        assert open(msg2.filename).read() == "some data"
+        assert msg2.filename.endswith("html.zip")
+        assert msg.filename != msg2.filename
+
+    def test_send_file_html_attachment(self, tmpdir, acfactory, lp):
+        ac1, ac2 = acfactory.get_two_online_accounts()
+        chat = self.get_chat(ac1, ac2)
+
+        basename = "test.html"
+        content = "<html><body>text</body>data"
+
+        p = os.path.join(tmpdir.strpath, basename)
+        with open(p, "w") as f:
+            # write wrong html to see if core tries to parse it
+            # (it shouldn't as it's a file attachment)
+            f.write(content)
+
+        lp.sec("ac1: prepare and send attachment + text to ac2")
+        chat.send_file(p, mime_type="text/html")

        lp.sec("ac2: receive message")
        ev = ac2._evlogger.get_matching("DC_EVENT_INCOMING_MSG|DC_EVENT_MSGS_CHANGED")
        assert ev[2] > const.DC_CHAT_ID_LAST_SPECIAL
-        msg = ac2.get_message_by_id(ev[1])
-        assert msg.text == "hello ä world"
-        assert open(msg.filename).read() == "some data"
+        msg = ac2.get_message_by_id(ev[2])
+
+        assert open(msg.filename).read() == content
        assert msg.filename.endswith(basename)

    def test_mvbox_sentbox_threads(self, acfactory, lp):
--- a/python/tox.ini
+++ b/python/tox.ini
@@ -7,11 +7,7 @@ envlist =

 [testenv]
 commands = 
-    # (some qr tests are pretty heavy in terms of send/received
-    # messages and async-imap's likely has concurrency problems, 
-    # eg https://github.com/async-email/async-imap/issues/4 )
-    pytest -n6 --reruns 3 --reruns-delay 5 -v -rsXx -k "not qr" {posargs:tests} 
-    pytest -n6 --reruns 5 --reruns-delay 5 -v -rsXx -k "qr" {posargs:tests} 
+    pytest -n6 --reruns 2 --reruns-delay 5 -v -rsXx {posargs:tests} 
    # python tests/package_wheels.py {toxworkdir}/wheelhouse
 passenv = 
    TRAVIS 
@@ -36,7 +32,7 @@ commands =

 [testenv:lint]
 skipsdist = True
-usedevelop = True
+skip_install = True
 deps =
    flake8
    # pygments required by rst-lint
--- a/src/aheader.rs
+++ b/src/aheader.rs
@@ -95,16 +95,25 @@ impl Aheader {

 impl fmt::Display for Aheader {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        // TODO replace 78 with enum /rtn
-        // adds a whitespace every 78 characters, this allows libEtPan to
-        // wrap the lines according to RFC 5322
+        write!(fmt, "addr={};", self.addr)?;
+        if self.prefer_encrypt == EncryptPreference::Mutual {
+            write!(fmt, " prefer-encrypt=mutual;")?;
+        }
+
+        // adds a whitespace every 78 characters, this allows
+        // email crate to wrap the lines according to RFC 5322
        // (which may insert a linebreak before every whitespace)
-        let keydata = self.public_key.to_base64(78);
-        write!(
-            fmt,
-            "addr={}; prefer-encrypt={}; keydata={}",
-            self.addr, self.prefer_encrypt, keydata
-        )
+        let keydata = self.public_key.to_base64().chars().enumerate().fold(
+            String::new(),
+            |mut res, (i, c)| {
+                if i % 78 == 78 - "keydata=".len() {
+                    res.push(' ')
+                }
+                res.push(c);
+                res
+            },
+        );
+        write!(fmt, " keydata={}", keydata)
    }
 }

@@ -150,13 +159,10 @@ impl str::FromStr for Aheader {
            }
        };

-        let prefer_encrypt = match attributes
+        let prefer_encrypt = attributes
            .remove("prefer-encrypt")
            .and_then(|raw| raw.parse().ok())
-        {
-            Some(pref) => pref,
-            None => EncryptPreference::NoPreference,
-        };
+            .unwrap_or_default();

        // Autocrypt-Level0: unknown attributes starting with an underscore can be safely ignored
        // Autocrypt-Level0: unknown attribute, treat the header as invalid
@@ -176,15 +182,13 @@ impl str::FromStr for Aheader {
 mod tests {
    use super::*;

-    fn rawkey() -> String {
-        "xsBNBFzG3j0BCAC6iNhT8zydvCXi8LI/gFnkadMbfmSE/rTJskRRra/utGbLyDta/yTrJgWL7O3y/g4HdDW/dN2z26Y6W13IMzx9gLInn1KQZChtqWAcr/ReUucXcymwcfg1mdkBGk3TSLeLihN6CJx8Wsv8ig+kgAzte4f5rqEEAJVQ9WZHuti7UiYs6oRzqTo06CRe9owVXxzdMf0VDQtf7ZFm9dpzKKbhH7Lu8880iiotQ9/yRCkDGp9fNThsrLdZiK6OIAcIBAqi2rI89aS1dAmnRbktQieCx5izzyYkR1KvVL3gTTllHOzfKVEC2asmtWu2e4se/+O4WMIS1eGrn7GeWVb0Vwc5ABEBAAHNETxhQEBiLmV4YW1wbGUuZGU+wsCJBBABCAAzAhkBBQJcxt5FAhsDBAsJCAcGFQgJCgsCAxYCARYhBI4xxYKBgH3ANh5cufaKrc9mtiMLAAoJEPaKrc9mtiML938H/18F+3Wf9/JaAy/8hCO1v4S2PVBhxaKCokaNFtkfaMRne2l087LscCFPiFNyb4mv6Z3YeK8Xpxlp2sI0ecvdiqLUOGfnxS6tQrj+83EjtIrZ/hXOk1h121QFWH9Zg2VNHtODXjAgdLDC0NWUrclR0ZOqEDQHeo0ibTILdokVfXFN25wakPmGaYJP2y729cb1ve7RzvIvwn+Dddfxo3ao72rBfLi7l4NQ4S0KsY4cw+/6l5bRCKYCP77wZtvCwUvfVVosLdT43agtSiBI49+ayqvZ8OCvSJa61i+v81brTiEy9GBod4eAp45Ibsuemkw+gon4ZOvUXHTjwFB+h63MrozOwE0EXMbePQEIAL/vauf1zK8JgCu3V+G+SOX0iWw5xUlCPX+ERpBbWfwu3uAqn4wYXD3JDE/fVAF668xiV4eTPtlSUd5h0mn+G7uXMMOtkb+20SoEt50f8zw8TrL9t+ZsV11GKZWJpCar5AhXWsn6EEi8I2hLL5vn55ZZmHuGgN4jjmkRl3ToKCLhaXwTBjCJem7N5EH7F75wErEITa55v4Lb4Nfca7vnvtYrI1OA446xa8gHra0SINelTD09/JM/Fw4sWVPBaRZmJK/Tnu79N23No9XBUubmFPv1pNexZsQclicnTpt/BEWhiun7d6lfGB63K1aoHRTR1pcrWvBuALuuz0gqar2zlI0AEQEAAcLAdgQYAQgAIAUCXMbeRQIbDBYhBI4xxYKBgH3ANh5cufaKrc9mtiMLAAoJEPaKrc9mtiMLKSEIAIyLCRO2OyZ0IYRvRPpMn4p7E+7Pfcz/0mSkOy+1hshgJnqivXurm8zwGrwdMqeV4eslKR9H1RUdWGUQJNbtwmmjrt5DHpIhYHl5t3FpCBaGbV20Omo00Q38lBl9MtrmZkZw+ktEk6X+0xCKssMF+2MADkSOIufbR5HrDVB89VZOHCO9DeXvCUUAw2hyJiL/LHmLzJ40zYoTmb+F//f0k0j+tRdbkefyRoCmwG7YGiT+2hnCdgcezswnzah5J3ZKlrg7jOGo1LxtbvNUzxNBbC6S/aNgwm6qxo7xegRhmEl5uZ16zwyj4qz+xkjGy25Of5mWfUDoNw7OT7sjUbHOOMc=".into()
-    }
+    const RAWKEY: &str = "xsBNBFzG3j0BCAC6iNhT8zydvCXi8LI/gFnkadMbfmSE/rTJskRRra/utGbLyDta/yTrJgWL7O3y/g4HdDW/dN2z26Y6W13IMzx9gLInn1KQZChtqWAcr/ReUucXcymwcfg1mdkBGk3TSLeLihN6CJx8Wsv8ig+kgAzte4f5rqEEAJVQ9WZHuti7UiYs6oRzqTo06CRe9owVXxzdMf0VDQtf7ZFm9dpzKKbhH7Lu8880iiotQ9/yRCkDGp9fNThsrLdZiK6OIAcIBAqi2rI89aS1dAmnRbktQieCx5izzyYkR1KvVL3gTTllHOzfKVEC2asmtWu2e4se/+O4WMIS1eGrn7GeWVb0Vwc5ABEBAAHNETxhQEBiLmV4YW1wbGUuZGU+wsCJBBABCAAzAhkBBQJcxt5FAhsDBAsJCAcGFQgJCgsCAxYCARYhBI4xxYKBgH3ANh5cufaKrc9mtiMLAAoJEPaKrc9mtiML938H/18F+3Wf9/JaAy/8hCO1v4S2PVBhxaKCokaNFtkfaMRne2l087LscCFPiFNyb4mv6Z3YeK8Xpxlp2sI0ecvdiqLUOGfnxS6tQrj+83EjtIrZ/hXOk1h121QFWH9Zg2VNHtODXjAgdLDC0NWUrclR0ZOqEDQHeo0ibTILdokVfXFN25wakPmGaYJP2y729cb1ve7RzvIvwn+Dddfxo3ao72rBfLi7l4NQ4S0KsY4cw+/6l5bRCKYCP77wZtvCwUvfVVosLdT43agtSiBI49+ayqvZ8OCvSJa61i+v81brTiEy9GBod4eAp45Ibsuemkw+gon4ZOvUXHTjwFB+h63MrozOwE0EXMbePQEIAL/vauf1zK8JgCu3V+G+SOX0iWw5xUlCPX+ERpBbWfwu3uAqn4wYXD3JDE/fVAF668xiV4eTPtlSUd5h0mn+G7uXMMOtkb+20SoEt50f8zw8TrL9t+ZsV11GKZWJpCar5AhXWsn6EEi8I2hLL5vn55ZZmHuGgN4jjmkRl3ToKCLhaXwTBjCJem7N5EH7F75wErEITa55v4Lb4Nfca7vnvtYrI1OA446xa8gHra0SINelTD09/JM/Fw4sWVPBaRZmJK/Tnu79N23No9XBUubmFPv1pNexZsQclicnTpt/BEWhiun7d6lfGB63K1aoHRTR1pcrWvBuALuuz0gqar2zlI0AEQEAAcLAdgQYAQgAIAUCXMbeRQIbDBYhBI4xxYKBgH3ANh5cufaKrc9mtiMLAAoJEPaKrc9mtiMLKSEIAIyLCRO2OyZ0IYRvRPpMn4p7E+7Pfcz/0mSkOy+1hshgJnqivXurm8zwGrwdMqeV4eslKR9H1RUdWGUQJNbtwmmjrt5DHpIhYHl5t3FpCBaGbV20Omo00Q38lBl9MtrmZkZw+ktEk6X+0xCKssMF+2MADkSOIufbR5HrDVB89VZOHCO9DeXvCUUAw2hyJiL/LHmLzJ40zYoTmb+F//f0k0j+tRdbkefyRoCmwG7YGiT+2hnCdgcezswnzah5J3ZKlrg7jOGo1LxtbvNUzxNBbC6S/aNgwm6qxo7xegRhmEl5uZ16zwyj4qz+xkjGy25Of5mWfUDoNw7OT7sjUbHOOMc=";

    #[test]
    fn test_from_str() {
        let h: Aheader = format!(
            "addr=me@mail.com; prefer-encrypt=mutual; keydata={}",
-            rawkey()
+            RAWKEY
        )
        .parse()
        .expect("failed to parse");
@@ -193,9 +197,22 @@ mod tests {
        assert_eq!(h.prefer_encrypt, EncryptPreference::Mutual);
    }

+    // EncryptPreference::Reset is an internal value, parser should never return it
+    #[test]
+    fn test_from_str_reset() {
+        let raw = format!(
+            "addr=reset@example.com; prefer-encrypt=reset; keydata={}",
+            RAWKEY
+        );
+        let h: Aheader = raw.parse().expect("failed to parse");
+
+        assert_eq!(h.addr, "reset@example.com");
+        assert_eq!(h.prefer_encrypt, EncryptPreference::NoPreference);
+    }
+
    #[test]
    fn test_from_str_non_critical() {
-        let raw = format!("addr=me@mail.com; _foo=one; _bar=two; keydata={}", rawkey());
+        let raw = format!("addr=me@mail.com; _foo=one; _bar=two; keydata={}", RAWKEY);
        let h: Aheader = raw.parse().expect("failed to parse");

        assert_eq!(h.addr, "me@mail.com");
@@ -206,33 +223,57 @@ mod tests {
    fn test_from_str_superflous_critical() {
        let raw = format!(
            "addr=me@mail.com; _foo=one; _bar=two; other=me; keydata={}",
-            rawkey()
+            RAWKEY
        );
        assert!(raw.parse::<Aheader>().is_err());
    }

    #[test]
    fn test_good_headers() {
-        let fixed_header = "addr=a@b.example.org; prefer-encrypt=mutual; keydata=xsBNBFzG3j0BCAC6iNhT8zydvCXi8LI/gFnkadMbfmSE/rTJskRRra/utGbLyDta/yTrJgWL7O3y/g 4HdDW/dN2z26Y6W13IMzx9gLInn1KQZChtqWAcr/ReUucXcymwcfg1mdkBGk3TSLeLihN6CJx8Wsv8 ig+kgAzte4f5rqEEAJVQ9WZHuti7UiYs6oRzqTo06CRe9owVXxzdMf0VDQtf7ZFm9dpzKKbhH7Lu88 80iiotQ9/yRCkDGp9fNThsrLdZiK6OIAcIBAqi2rI89aS1dAmnRbktQieCx5izzyYkR1KvVL3gTTll HOzfKVEC2asmtWu2e4se/+O4WMIS1eGrn7GeWVb0Vwc5ABEBAAHNETxhQEBiLmV4YW1wbGUuZGU+ws CJBBABCAAzAhkBBQJcxt5FAhsDBAsJCAcGFQgJCgsCAxYCARYhBI4xxYKBgH3ANh5cufaKrc9mtiML AAoJEPaKrc9mtiML938H/18F+3Wf9/JaAy/8hCO1v4S2PVBhxaKCokaNFtkfaMRne2l087LscCFPiF Nyb4mv6Z3YeK8Xpxlp2sI0ecvdiqLUOGfnxS6tQrj+83EjtIrZ/hXOk1h121QFWH9Zg2VNHtODXjAg dLDC0NWUrclR0ZOqEDQHeo0ibTILdokVfXFN25wakPmGaYJP2y729cb1ve7RzvIvwn+Dddfxo3ao72 rBfLi7l4NQ4S0KsY4cw+/6l5bRCKYCP77wZtvCwUvfVVosLdT43agtSiBI49+ayqvZ8OCvSJa61i+v 81brTiEy9GBod4eAp45Ibsuemkw+gon4ZOvUXHTjwFB+h63MrozOwE0EXMbePQEIAL/vauf1zK8JgC u3V+G+SOX0iWw5xUlCPX+ERpBbWfwu3uAqn4wYXD3JDE/fVAF668xiV4eTPtlSUd5h0mn+G7uXMMOt kb+20SoEt50f8zw8TrL9t+ZsV11GKZWJpCar5AhXWsn6EEi8I2hLL5vn55ZZmHuGgN4jjmkRl3ToKC LhaXwTBjCJem7N5EH7F75wErEITa55v4Lb4Nfca7vnvtYrI1OA446xa8gHra0SINelTD09/JM/Fw4s WVPBaRZmJK/Tnu79N23No9XBUubmFPv1pNexZsQclicnTpt/BEWhiun7d6lfGB63K1aoHRTR1pcrWv BuALuuz0gqar2zlI0AEQEAAcLAdgQYAQgAIAUCXMbeRQIbDBYhBI4xxYKBgH3ANh5cufaKrc9mtiML AAoJEPaKrc9mtiMLKSEIAIyLCRO2OyZ0IYRvRPpMn4p7E+7Pfcz/0mSkOy+1hshgJnqivXurm8zwGr wdMqeV4eslKR9H1RUdWGUQJNbtwmmjrt5DHpIhYHl5t3FpCBaGbV20Omo00Q38lBl9MtrmZkZw+ktE k6X+0xCKssMF+2MADkSOIufbR5HrDVB89VZOHCO9DeXvCUUAw2hyJiL/LHmLzJ40zYoTmb+F//f0k0 j+tRdbkefyRoCmwG7YGiT+2hnCdgcezswnzah5J3ZKlrg7jOGo1LxtbvNUzxNBbC6S/aNgwm6qxo7x egRhmEl5uZ16zwyj4qz+xkjGy25Of5mWfUDoNw7OT7sjUbHOOMc=";
+        let fixed_header = concat!(
+            "addr=a@b.example.org; prefer-encrypt=mutual; ",
+            "keydata=xsBNBFzG3j0BCAC6iNhT8zydvCXi8LI/gFnkadMbfmSE/rTJskRRra/utGbLyDta/yTrJg",
+            " WL7O3y/g4HdDW/dN2z26Y6W13IMzx9gLInn1KQZChtqWAcr/ReUucXcymwcfg1mdkBGk3TSLeLihN6",
+            " CJx8Wsv8ig+kgAzte4f5rqEEAJVQ9WZHuti7UiYs6oRzqTo06CRe9owVXxzdMf0VDQtf7ZFm9dpzKK",
+            " bhH7Lu8880iiotQ9/yRCkDGp9fNThsrLdZiK6OIAcIBAqi2rI89aS1dAmnRbktQieCx5izzyYkR1Kv",
+            " VL3gTTllHOzfKVEC2asmtWu2e4se/+O4WMIS1eGrn7GeWVb0Vwc5ABEBAAHNETxhQEBiLmV4YW1wbG",
+            " UuZGU+wsCJBBABCAAzAhkBBQJcxt5FAhsDBAsJCAcGFQgJCgsCAxYCARYhBI4xxYKBgH3ANh5cufaK",
+            " rc9mtiMLAAoJEPaKrc9mtiML938H/18F+3Wf9/JaAy/8hCO1v4S2PVBhxaKCokaNFtkfaMRne2l087",
+            " LscCFPiFNyb4mv6Z3YeK8Xpxlp2sI0ecvdiqLUOGfnxS6tQrj+83EjtIrZ/hXOk1h121QFWH9Zg2VN",
+            " HtODXjAgdLDC0NWUrclR0ZOqEDQHeo0ibTILdokVfXFN25wakPmGaYJP2y729cb1ve7RzvIvwn+Ddd",
+            " fxo3ao72rBfLi7l4NQ4S0KsY4cw+/6l5bRCKYCP77wZtvCwUvfVVosLdT43agtSiBI49+ayqvZ8OCv",
+            " SJa61i+v81brTiEy9GBod4eAp45Ibsuemkw+gon4ZOvUXHTjwFB+h63MrozOwE0EXMbePQEIAL/vau",
+            " f1zK8JgCu3V+G+SOX0iWw5xUlCPX+ERpBbWfwu3uAqn4wYXD3JDE/fVAF668xiV4eTPtlSUd5h0mn+",
+            " G7uXMMOtkb+20SoEt50f8zw8TrL9t+ZsV11GKZWJpCar5AhXWsn6EEi8I2hLL5vn55ZZmHuGgN4jjm",
+            " kRl3ToKCLhaXwTBjCJem7N5EH7F75wErEITa55v4Lb4Nfca7vnvtYrI1OA446xa8gHra0SINelTD09",
+            " /JM/Fw4sWVPBaRZmJK/Tnu79N23No9XBUubmFPv1pNexZsQclicnTpt/BEWhiun7d6lfGB63K1aoHR",
+            " TR1pcrWvBuALuuz0gqar2zlI0AEQEAAcLAdgQYAQgAIAUCXMbeRQIbDBYhBI4xxYKBgH3ANh5cufaK",
+            " rc9mtiMLAAoJEPaKrc9mtiMLKSEIAIyLCRO2OyZ0IYRvRPpMn4p7E+7Pfcz/0mSkOy+1hshgJnqivX",
+            " urm8zwGrwdMqeV4eslKR9H1RUdWGUQJNbtwmmjrt5DHpIhYHl5t3FpCBaGbV20Omo00Q38lBl9Mtrm",
+            " ZkZw+ktEk6X+0xCKssMF+2MADkSOIufbR5HrDVB89VZOHCO9DeXvCUUAw2hyJiL/LHmLzJ40zYoTmb",
+            " +F//f0k0j+tRdbkefyRoCmwG7YGiT+2hnCdgcezswnzah5J3ZKlrg7jOGo1LxtbvNUzxNBbC6S/aNg",
+            " wm6qxo7xegRhmEl5uZ16zwyj4qz+xkjGy25Of5mWfUDoNw7OT7sjUbHOOMc="
+        );

        let ah = Aheader::from_str(fixed_header).expect("failed to parse");
        assert_eq!(ah.addr, "a@b.example.org");
        assert_eq!(ah.prefer_encrypt, EncryptPreference::Mutual);
+        assert_eq!(format!("{}", ah), fixed_header);

        let rendered = ah.to_string();
        assert_eq!(rendered, fixed_header);

-        let ah = Aheader::from_str(&format!(" _foo; __FOO=BAR ;;; addr = a@b.example.org ;\r\n   prefer-encrypt = mutual ; keydata = {}", rawkey())).expect("failed to parse");
+        let ah = Aheader::from_str(&format!(" _foo; __FOO=BAR ;;; addr = a@b.example.org ;\r\n   prefer-encrypt = mutual ; keydata = {}", RAWKEY)).expect("failed to parse");
        assert_eq!(ah.addr, "a@b.example.org");
        assert_eq!(ah.prefer_encrypt, EncryptPreference::Mutual);

        Aheader::from_str(&format!(
            "addr=a@b.example.org; prefer-encrypt=ignoreUnknownValues; keydata={}",
-            rawkey()
+            RAWKEY
        ))
        .expect("failed to parse");

-        Aheader::from_str(&format!("addr=a@b.example.org; keydata={}", rawkey()))
+        Aheader::from_str(&format!("addr=a@b.example.org; keydata={}", RAWKEY))
            .expect("failed to parse");
    }

@@ -244,4 +285,30 @@ mod tests {
        assert!(Aheader::from_str(" ;;").is_err());
        assert!(Aheader::from_str("addr=a@t.de; unknwon=1; keydata=jau").is_err());
    }
+
+    #[test]
+    fn test_display_aheader() {
+        assert!(format!(
+            "{}",
+            Aheader::new(
+                "test@example.com".to_string(),
+                Key::from_base64(RAWKEY, KeyType::Public).unwrap(),
+                EncryptPreference::Mutual
+            )
+        )
+        .contains("prefer-encrypt=mutual;"));
+
+        // According to Autocrypt Level 1 specification,
+        // only "prefer-encrypt=mutual;" can be used.
+        // If the setting is nopreference, the whole attribute is omitted.
+        assert!(!format!(
+            "{}",
+            Aheader::new(
+                "test@example.com".to_string(),
+                Key::from_base64(RAWKEY, KeyType::Public).unwrap(),
+                EncryptPreference::NoPreference
+            )
+        )
+        .contains("prefer-encrypt"));
+    }
 }
--- a/src/chat.rs
+++ b/src/chat.rs
@@ -725,11 +725,21 @@ 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) {
-        let blob = msg
-            .param
-            .get_blob(Param::File, context, !msg.is_increation())?
-            .ok_or_else(|| format_err!("Attachment missing for message of type #{}", msg.type_0))?;
-        msg.param.set(Param::File, blob.as_name());
+        let blob = if let Some(f) = msg.param.get_file(Param::File, context)? {
+            match f {
+                ParamsFile::Blob(blob) => blob,
+                ParamsFile::FsPath(path) => {
+                    // path is outside the blobdir, let's copy
+                    let blob = BlobObject::create_and_copy(context, path)?;
+                    msg.param.set(Param::File, blob.as_name());
+
+                    blob
+                }
+            }
+        } else {
+            bail!("Attachment missing for message of type #{}", msg.type_0);
+        };
+
        if msg.type_0 == Viewtype::File || msg.type_0 == Viewtype::Image {
            // Correct the type, take care not to correct already very special
            // formats as GIF or VOICE.
--- a/src/configure/auto_mozilla.rs
+++ b/src/configure/auto_mozilla.rs
@@ -1,8 +1,6 @@
 //! # Thunderbird's Autoconfiguration implementation
 //!
 //! Documentation: https://developer.mozilla.org/en-US/docs/Mozilla/Thunderbird/Autoconfiguration */
-use failure::Fail;
-
 use quick_xml;
 use quick_xml::events::{BytesEnd, BytesStart, BytesText};

--- a/src/configure/auto_outlook.rs
+++ b/src/configure/auto_outlook.rs
@@ -1,7 +1,5 @@
 //! Outlook's Autodiscover

-use failure::Fail;
-
 use quick_xml;
 use quick_xml::events::BytesEnd;

--- a/src/configure/read_url.rs
+++ b/src/configure/read_url.rs
@@ -1,5 +1,4 @@
 use crate::context::Context;
-use failure::Fail;

 #[derive(Debug, Fail)]
 pub enum Error {
--- a/src/dc_receive_imf.rs
+++ b/src/dc_receive_imf.rs
@@ -47,7 +47,7 @@ pub fn dc_receive_imf(
        server_uid,
    );

-    if std::env::var(crate::DCC_MIME_DEBUG).is_ok() {
+    if std::env::var(crate::DCC_MIME_DEBUG).unwrap_or_default() == "2" {
        info!(context, "dc_receive_imf: incoming message mime-body:");
        println!("{}", String::from_utf8_lossy(imf_raw));
    }
@@ -337,7 +337,7 @@ fn add_parts(
    }

    // 1 or 0 for yes/no
-    msgrmsg = mime_parser.is_send_by_messenger as _;
+    msgrmsg = mime_parser.has_chat_version() as _;
    if msgrmsg == 0 && 0 != dc_is_reply_to_messenger_message(context, mime_parser) {
        // 2=no, but is reply to messenger message
        msgrmsg = 2;
@@ -1112,7 +1112,7 @@ fn create_or_lookup_group(
    // the only critical situation is if the user hits "Reply" instead
    // of "Reply all" in a non-messenger-client */
    if to_ids_cnt == 1
-        && !mime_parser.is_send_by_messenger
+        && !mime_parser.has_chat_version()
        && chat::get_chat_contact_cnt(context, chat_id) > 3
    {
        // to_ids_cnt==1 may be "From: A, To: B, SELF" as SELF is not counted in to_ids_cnt.
--- a/src/dc_tools.rs
+++ b/src/dc_tools.rs
@@ -278,11 +278,9 @@ pub fn dc_derive_safe_stem_ext(filename: &str) -> (String, String) {
 // the returned suffix is lower-case
 #[allow(non_snake_case)]
 pub fn dc_get_filesuffix_lc(path_filename: impl AsRef<str>) -> Option<String> {
-    if let Some(p) = Path::new(path_filename.as_ref()).extension() {
-        Some(p.to_string_lossy().to_lowercase())
-    } else {
-        None
-    }
+    Path::new(path_filename.as_ref())
+        .extension()
+        .map(|p| p.to_string_lossy().to_lowercase())
 }

 /// Returns the `(width, height)` of the given image buffer.
--- a/src/e2ee.rs
+++ b/src/e2ee.rs
@@ -247,13 +247,13 @@ fn decrypt_if_autocrypt_message<'a>(
    // Errors are returned for failures related to decryption of AC-messages.

    let encrypted_data_part = match wrapmime::get_autocrypt_mime(mail) {
-        Err(err) => {
-            // not a proper autocrypt message, abort and ignore
-            info!(context, "Not an autocrypt message: {:?}", err);
+        Err(_) => {
+            // not an autocrypt mime message, abort and ignore
            return Ok(None);
        }
        Ok(res) => res,
    };
+    info!(context, "Detected Autocrypt-mime message");

    decrypt_part(
        context,
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,6 +1,5 @@
 //! # Error handling

-use failure::Fail;
 use lettre_email::mime;

 #[derive(Debug, Fail)]
--- a/src/imap/idle.rs
+++ b/src/imap/idle.rs
@@ -0,0 +1,250 @@
+use super::Imap;
+
+use async_imap::extensions::idle::IdleResponse;
+use async_std::prelude::*;
+use async_std::task;
+use std::sync::atomic::Ordering;
+use std::time::{Duration, SystemTime};
+
+use crate::context::Context;
+use crate::imap_client::*;
+
+use super::select_folder;
+
+type Result<T> = std::result::Result<T, Error>;
+
+#[derive(Debug, Fail)]
+pub enum Error {
+    #[fail(display = "IMAP IDLE protocol failed to init/complete")]
+    IdleProtocolFailed(#[cause] async_imap::error::Error),
+
+    #[fail(display = "IMAP server does not have IDLE capability")]
+    IdleAbilityMissing,
+
+    #[fail(display = "IMAP select folder error")]
+    SelectFolderError(#[cause] select_folder::Error),
+
+    #[fail(display = "IMAP error")]
+    ImapError(#[cause] async_imap::error::Error),
+
+    #[fail(display = "Setup handle error")]
+    SetupHandleError(#[cause] super::Error),
+}
+
+impl From<select_folder::Error> for Error {
+    fn from(err: select_folder::Error) -> Error {
+        Error::SelectFolderError(err)
+    }
+}
+
+impl Imap {
+    pub fn can_idle(&self) -> bool {
+        task::block_on(async move { self.config.read().await.can_idle })
+    }
+
+    pub fn idle(&self, context: &Context, watch_folder: Option<String>) -> Result<()> {
+        task::block_on(async move {
+            if !self.can_idle() {
+                return Err(Error::IdleAbilityMissing);
+            }
+
+            self.setup_handle_if_needed(context)
+                .await
+                .map_err(Error::SetupHandleError)?;
+
+            self.select_folder(context, watch_folder.clone()).await?;
+
+            let session = self.session.lock().await.take();
+            let timeout = Duration::from_secs(23 * 60);
+            if let Some(session) = session {
+                match session.idle() {
+                    // BEWARE: If you change the Secure branch you
+                    // typically also need to change the Insecure branch.
+                    IdleHandle::Secure(mut handle) => {
+                        if let Err(err) = handle.init().await {
+                            return Err(Error::IdleProtocolFailed(err));
+                        }
+
+                        let (idle_wait, interrupt) = handle.wait_with_timeout(timeout);
+                        *self.interrupt.lock().await = Some(interrupt);
+
+                        if self.skip_next_idle_wait.load(Ordering::SeqCst) {
+                            // interrupt_idle has happened before we
+                            // provided self.interrupt
+                            self.skip_next_idle_wait.store(false, Ordering::SeqCst);
+                            std::mem::drop(idle_wait);
+                            info!(context, "Idle wait was skipped");
+                        } else {
+                            info!(context, "Idle entering wait-on-remote state");
+                            match idle_wait.await {
+                                IdleResponse::NewData(_) => {
+                                    info!(context, "Idle has NewData");
+                                }
+                                // TODO: idle_wait does not distinguish manual interrupts
+                                // from Timeouts if we would know it's a Timeout we could bail
+                                // directly and reconnect .
+                                IdleResponse::Timeout => {
+                                    info!(context, "Idle-wait timeout or interruption");
+                                }
+                                IdleResponse::ManualInterrupt => {
+                                    info!(context, "Idle wait was interrupted");
+                                }
+                            }
+                        }
+                        match handle.done().await {
+                            Ok(session) => {
+                                *self.session.lock().await = Some(Session::Secure(session));
+                            }
+                            Err(err) => {
+                                // if we cannot terminate IDLE it probably
+                                // means that we waited long (with idle_wait)
+                                // but the network went away/changed
+                                self.trigger_reconnect();
+                                return Err(Error::IdleProtocolFailed(err));
+                            }
+                        }
+                    }
+                    IdleHandle::Insecure(mut handle) => {
+                        if let Err(err) = handle.init().await {
+                            return Err(Error::IdleProtocolFailed(err));
+                        }
+
+                        let (idle_wait, interrupt) = handle.wait_with_timeout(timeout);
+                        *self.interrupt.lock().await = Some(interrupt);
+
+                        if self.skip_next_idle_wait.load(Ordering::SeqCst) {
+                            // interrupt_idle has happened before we
+                            // provided self.interrupt
+                            self.skip_next_idle_wait.store(false, Ordering::SeqCst);
+                            std::mem::drop(idle_wait);
+                            info!(context, "Idle wait was skipped");
+                        } else {
+                            info!(context, "Idle entering wait-on-remote state");
+                            match idle_wait.await {
+                                IdleResponse::NewData(_) => {
+                                    info!(context, "Idle has NewData");
+                                }
+                                // TODO: idle_wait does not distinguish manual interrupts
+                                // from Timeouts if we would know it's a Timeout we could bail
+                                // directly and reconnect .
+                                IdleResponse::Timeout => {
+                                    info!(context, "Idle-wait timeout or interruption");
+                                }
+                                IdleResponse::ManualInterrupt => {
+                                    info!(context, "Idle wait was interrupted");
+                                }
+                            }
+                        }
+                        match handle.done().await {
+                            Ok(session) => {
+                                *self.session.lock().await = Some(Session::Insecure(session));
+                            }
+                            Err(err) => {
+                                // if we cannot terminate IDLE it probably
+                                // means that we waited long (with idle_wait)
+                                // but the network went away/changed
+                                self.trigger_reconnect();
+                                return Err(Error::IdleProtocolFailed(err));
+                            }
+                        }
+                    }
+                }
+            }
+
+            Ok(())
+        })
+    }
+
+    pub(crate) fn fake_idle(&self, context: &Context, watch_folder: Option<String>) {
+        // Idle using polling. This is also needed if we're not yet configured -
+        // in this case, we're waiting for a configure job (and an interrupt).
+        task::block_on(async move {
+            let fake_idle_start_time = SystemTime::now();
+
+            info!(context, "IMAP-fake-IDLEing...");
+
+            let interrupt = stop_token::StopSource::new();
+
+            // check every minute if there are new messages
+            // TODO: grow sleep durations / make them more flexible
+            let interval = async_std::stream::interval(Duration::from_secs(60));
+            let mut interrupt_interval = interrupt.stop_token().stop_stream(interval);
+            *self.interrupt.lock().await = Some(interrupt);
+            if self.skip_next_idle_wait.load(Ordering::SeqCst) {
+                // interrupt_idle has happened before we
+                // provided self.interrupt
+                self.skip_next_idle_wait.store(false, Ordering::SeqCst);
+                info!(context, "fake-idle wait was skipped");
+            } else {
+                // loop until we are interrupted or if we fetched something
+                while let Some(_) = interrupt_interval.next().await {
+                    // try to connect with proper login params
+                    // (setup_handle_if_needed might not know about them if we
+                    // never successfully connected)
+                    if let Err(err) = self.connect_configured(context) {
+                        warn!(context, "fake_idle: could not connect: {}", err);
+                        continue;
+                    }
+                    if self.config.read().await.can_idle {
+                        // we only fake-idled because network was gone during IDLE, probably
+                        break;
+                    }
+                    info!(context, "fake_idle is connected");
+                    // we are connected, let's see if fetching messages results
+                    // in anything.  If so, we behave as if IDLE had data but
+                    // will have already fetched the messages so perform_*_fetch
+                    // will not find any new.
+
+                    if let Some(ref watch_folder) = watch_folder {
+                        match self.fetch_new_messages(context, watch_folder).await {
+                            Ok(res) => {
+                                info!(context, "fetch_new_messages returned {:?}", res);
+                                if res {
+                                    break;
+                                }
+                            }
+                            Err(err) => {
+                                error!(context, "could not fetch from folder: {}", err);
+                                self.trigger_reconnect()
+                            }
+                        }
+                    }
+                }
+            }
+            self.interrupt.lock().await.take();
+
+            info!(
+                context,
+                "IMAP-fake-IDLE done after {:.4}s",
+                SystemTime::now()
+                    .duration_since(fake_idle_start_time)
+                    .unwrap()
+                    .as_millis() as f64
+                    / 1000.,
+            );
+        })
+    }
+
+    pub fn interrupt_idle(&self, context: &Context) {
+        task::block_on(async move {
+            let mut interrupt: Option<stop_token::StopSource> = self.interrupt.lock().await.take();
+            if interrupt.is_none() {
+                // idle wait is not running, signal it needs to skip
+                self.skip_next_idle_wait.store(true, Ordering::SeqCst);
+
+                // meanwhile idle-wait may have produced the StopSource
+                interrupt = self.interrupt.lock().await.take();
+            }
+            // let's manually drop the StopSource
+            if interrupt.is_some() {
+                // the imap thread provided us a stop token but might
+                // not have entered idle_wait yet, give it some time
+                // for that to happen. XXX handle this without extra wait
+                // https://github.com/deltachat/deltachat-core-rust/issues/925
+                std::thread::sleep(Duration::from_millis(200));
+                info!(context, "low-level: dropping stop-source to interrupt idle");
+                std::mem::drop(interrupt)
+            }
+        });
+    }
+}
--- a/src/imap/mod.rs
+++ b/src/imap/mod.rs
@@ -4,14 +4,11 @@
 //! to implement connect, fetch, delete functionality with standard IMAP servers.

 use std::sync::atomic::{AtomicBool, Ordering};
-use std::time::{Duration, SystemTime};

 use async_imap::{
    error::Result as ImapResult,
-    extensions::idle::IdleResponse,
    types::{Fetch, Flag, Mailbox, Name, NameAttribute},
 };
-use async_std::prelude::*;
 use async_std::sync::{Mutex, RwLock};
 use async_std::task;

@@ -28,6 +25,7 @@ use crate::param::Params;
 use crate::stock::StockMessage;
 use crate::wrapmime;

+mod idle;
 pub mod select_folder;

 const DC_IMAP_SEEN: usize = 0x0001;
@@ -51,22 +49,16 @@ pub enum Error {
    #[fail(display = "IMAP Could not login as {}", _0)]
    LoginFailed(String),

-    #[fail(display = "IMAP Could not fetch {}", _0)]
+    #[fail(display = "IMAP Could not fetch")]
    FetchFailed(#[cause] async_imap::error::Error),

-    #[fail(display = "IMAP IDLE protocol failed to init/complete")]
-    IdleProtocolFailed(#[cause] async_imap::error::Error),
-
-    #[fail(display = "IMAP server does not have IDLE capability")]
-    IdleAbilityMissing,
-
    #[fail(display = "IMAP operation attempted while it is torn down")]
    InTeardown,

    #[fail(display = "IMAP operation attempted while it is torn down")]
    SqlError(#[cause] crate::sql::Error),

-    #[fail(display = "IMAP got error from elsewhere: {:?}", _0)]
+    #[fail(display = "IMAP got error from elsewhere")]
    WrappedError(#[cause] crate::error::Error),

    #[fail(display = "IMAP select folder error")]
@@ -438,19 +430,17 @@ impl Imap {
        });
    }

-    pub fn fetch(&self, context: &Context, watch_folder: &str) -> Result<()> {
-        task::block_on(async move {
-            if !context.sql.is_open() {
-                // probably shutdown
-                return Err(Error::InTeardown);
-            }
-            self.setup_handle_if_needed(context).await?;
+    pub async fn fetch(&self, context: &Context, watch_folder: &str) -> Result<()> {
+        if !context.sql.is_open() {
+            // probably shutdown
+            return Err(Error::InTeardown);
+        }
+        self.setup_handle_if_needed(context).await?;

-            while self.fetch_new_messages(context, &watch_folder).await? {
-                // We fetch until no more new messages are there.
-            }
-            Ok(())
-        })
+        while self.fetch_new_messages(context, &watch_folder).await? {
+            // We fetch until no more new messages are there.
+        }
+        Ok(())
    }

    fn get_config_last_seen_uid<S: AsRef<str>>(&self, context: &Context, folder: S) -> (u32, u32) {
@@ -730,210 +720,6 @@ impl Imap {
        1
    }

-    pub fn idle(&self, context: &Context, watch_folder: Option<String>) -> Result<()> {
-        task::block_on(async move {
-            if !self.config.read().await.can_idle {
-                return Err(Error::IdleAbilityMissing);
-            }
-
-            self.setup_handle_if_needed(context).await?;
-
-            self.select_folder(context, watch_folder.clone()).await?;
-
-            let session = self.session.lock().await.take();
-            let timeout = Duration::from_secs(23 * 60);
-            if let Some(session) = session {
-                match session.idle() {
-                    // BEWARE: If you change the Secure branch you
-                    // typically also need to change the Insecure branch.
-                    IdleHandle::Secure(mut handle) => {
-                        if let Err(err) = handle.init().await {
-                            return Err(Error::IdleProtocolFailed(err));
-                        }
-
-                        let (idle_wait, interrupt) = handle.wait_with_timeout(timeout);
-                        *self.interrupt.lock().await = Some(interrupt);
-
-                        if self.skip_next_idle_wait.load(Ordering::SeqCst) {
-                            // interrupt_idle has happened before we
-                            // provided self.interrupt
-                            self.skip_next_idle_wait.store(false, Ordering::SeqCst);
-                            std::mem::drop(idle_wait);
-                            info!(context, "Idle wait was skipped");
-                        } else {
-                            info!(context, "Idle entering wait-on-remote state");
-                            match idle_wait.await {
-                                IdleResponse::NewData(_) => {
-                                    info!(context, "Idle has NewData");
-                                }
-                                // TODO: idle_wait does not distinguish manual interrupts
-                                // from Timeouts if we would know it's a Timeout we could bail
-                                // directly and reconnect .
-                                IdleResponse::Timeout => {
-                                    info!(context, "Idle-wait timeout or interruption");
-                                }
-                                IdleResponse::ManualInterrupt => {
-                                    info!(context, "Idle wait was interrupted");
-                                }
-                            }
-                        }
-                        match handle.done().await {
-                            Ok(session) => {
-                                *self.session.lock().await = Some(Session::Secure(session));
-                            }
-                            Err(err) => {
-                                // if we cannot terminate IDLE it probably
-                                // means that we waited long (with idle_wait)
-                                // but the network went away/changed
-                                self.trigger_reconnect();
-                                return Err(Error::IdleProtocolFailed(err));
-                            }
-                        }
-                    }
-                    IdleHandle::Insecure(mut handle) => {
-                        if let Err(err) = handle.init().await {
-                            return Err(Error::IdleProtocolFailed(err));
-                        }
-
-                        let (idle_wait, interrupt) = handle.wait_with_timeout(timeout);
-                        *self.interrupt.lock().await = Some(interrupt);
-
-                        if self.skip_next_idle_wait.load(Ordering::SeqCst) {
-                            // interrupt_idle has happened before we
-                            // provided self.interrupt
-                            self.skip_next_idle_wait.store(false, Ordering::SeqCst);
-                            std::mem::drop(idle_wait);
-                            info!(context, "Idle wait was skipped");
-                        } else {
-                            info!(context, "Idle entering wait-on-remote state");
-                            match idle_wait.await {
-                                IdleResponse::NewData(_) => {
-                                    info!(context, "Idle has NewData");
-                                }
-                                // TODO: idle_wait does not distinguish manual interrupts
-                                // from Timeouts if we would know it's a Timeout we could bail
-                                // directly and reconnect .
-                                IdleResponse::Timeout => {
-                                    info!(context, "Idle-wait timeout or interruption");
-                                }
-                                IdleResponse::ManualInterrupt => {
-                                    info!(context, "Idle wait was interrupted");
-                                }
-                            }
-                        }
-                        match handle.done().await {
-                            Ok(session) => {
-                                *self.session.lock().await = Some(Session::Insecure(session));
-                            }
-                            Err(err) => {
-                                // if we cannot terminate IDLE it probably
-                                // means that we waited long (with idle_wait)
-                                // but the network went away/changed
-                                self.trigger_reconnect();
-                                return Err(Error::IdleProtocolFailed(err));
-                            }
-                        }
-                    }
-                }
-            }
-
-            Ok(())
-        })
-    }
-
-    pub(crate) fn fake_idle(&self, context: &Context, watch_folder: Option<String>) {
-        // Idle using polling. This is also needed if we're not yet configured -
-        // in this case, we're waiting for a configure job (and an interrupt).
-        task::block_on(async move {
-            let fake_idle_start_time = SystemTime::now();
-
-            info!(context, "IMAP-fake-IDLEing...");
-
-            let interrupt = stop_token::StopSource::new();
-
-            // check every minute if there are new messages
-            // TODO: grow sleep durations / make them more flexible
-            let interval = async_std::stream::interval(Duration::from_secs(60));
-            let mut interrupt_interval = interrupt.stop_token().stop_stream(interval);
-            *self.interrupt.lock().await = Some(interrupt);
-            if self.skip_next_idle_wait.load(Ordering::SeqCst) {
-                // interrupt_idle has happened before we
-                // provided self.interrupt
-                self.skip_next_idle_wait.store(false, Ordering::SeqCst);
-                info!(context, "fake-idle wait was skipped");
-            } else {
-                // loop until we are interrupted or if we fetched something
-                while let Some(_) = interrupt_interval.next().await {
-                    // try to connect with proper login params
-                    // (setup_handle_if_needed might not know about them if we
-                    // never successfully connected)
-                    if let Err(err) = self.connect_configured(context) {
-                        warn!(context, "fake_idle: could not connect: {}", err);
-                        continue;
-                    }
-                    if self.config.read().await.can_idle {
-                        // we only fake-idled because network was gone during IDLE, probably
-                        break;
-                    }
-                    info!(context, "fake_idle is connected");
-                    // we are connected, let's see if fetching messages results
-                    // in anything.  If so, we behave as if IDLE had data but
-                    // will have already fetched the messages so perform_*_fetch
-                    // will not find any new.
-
-                    if let Some(ref watch_folder) = watch_folder {
-                        match self.fetch_new_messages(context, watch_folder).await {
-                            Ok(res) => {
-                                info!(context, "fetch_new_messages returned {:?}", res);
-                                if res {
-                                    break;
-                                }
-                            }
-                            Err(err) => {
-                                error!(context, "could not fetch from folder: {}", err);
-                                self.trigger_reconnect()
-                            }
-                        }
-                    }
-                }
-            }
-            self.interrupt.lock().await.take();
-
-            info!(
-                context,
-                "IMAP-fake-IDLE done after {:.4}s",
-                SystemTime::now()
-                    .duration_since(fake_idle_start_time)
-                    .unwrap()
-                    .as_millis() as f64
-                    / 1000.,
-            );
-        })
-    }
-
-    pub fn interrupt_idle(&self, context: &Context) {
-        task::block_on(async move {
-            let mut interrupt: Option<stop_token::StopSource> = self.interrupt.lock().await.take();
-            if interrupt.is_none() {
-                // idle wait is not running, signal it needs to skip
-                self.skip_next_idle_wait.store(true, Ordering::SeqCst);
-
-                // meanwhile idle-wait may have produced the StopSource
-                interrupt = self.interrupt.lock().await.take();
-            }
-            // let's manually drop the StopSource
-            if interrupt.is_some() {
-                // the imap thread provided us a stop token but might
-                // not have entered idle_wait yet, give it some time
-                // for that to happen. XXX handle this without extra wait
-                // https://github.com/deltachat/deltachat-core-rust/issues/925
-                std::thread::sleep(Duration::from_millis(200));
-                info!(context, "low-level: dropping stop-source to interrupt idle");
-                std::mem::drop(interrupt)
-            }
-        });
-    }
-
    pub fn mv(
        &self,
        context: &Context,
--- a/src/job.rs
+++ b/src/job.rs
@@ -8,6 +8,8 @@ use std::time::Duration;
 use deltachat_derive::{FromSql, ToSql};
 use rand::{thread_rng, Rng};

+use async_std::task;
+
 use crate::blob::BlobObject;
 use crate::chat;
 use crate::config::Config;
@@ -398,31 +400,37 @@ pub fn job_kill_action(context: &Context, action: Action) -> bool {
 pub fn perform_inbox_fetch(context: &Context) {
    let use_network = context.get_config_bool(Config::InboxWatch);

-    context
-        .inbox_thread
-        .write()
-        .unwrap()
-        .fetch(context, use_network);
+    task::block_on(
+        context
+            .inbox_thread
+            .write()
+            .unwrap()
+            .fetch(context, use_network),
+    );
 }

 pub fn perform_mvbox_fetch(context: &Context) {
    let use_network = context.get_config_bool(Config::MvboxWatch);

-    context
-        .mvbox_thread
-        .write()
-        .unwrap()
-        .fetch(context, use_network);
+    task::block_on(
+        context
+            .mvbox_thread
+            .write()
+            .unwrap()
+            .fetch(context, use_network),
+    );
 }

 pub fn perform_sentbox_fetch(context: &Context) {
    let use_network = context.get_config_bool(Config::SentboxWatch);

-    context
-        .sentbox_thread
-        .write()
-        .unwrap()
-        .fetch(context, use_network);
+    task::block_on(
+        context
+            .sentbox_thread
+            .write()
+            .unwrap()
+            .fetch(context, use_network),
+    );
 }

 pub fn perform_inbox_idle(context: &Context) {
--- a/src/job_thread.rs
+++ b/src/job_thread.rs
@@ -73,7 +73,7 @@ impl JobThread {
        info!(context, "Interrupting {}-IDLE... finished", self.name);
    }

-    pub fn fetch(&mut self, context: &Context, use_network: bool) {
+    pub async fn fetch(&mut self, context: &Context, use_network: bool) {
        {
            let &(ref lock, _) = &*self.state.clone();
            let mut state = lock.lock().unwrap();
@@ -86,10 +86,10 @@ impl JobThread {
        }

        if use_network {
-            if let Err(err) = self.connect_and_fetch(context) {
+            if let Err(err) = self.connect_and_fetch(context).await {
                warn!(context, "connect+fetch failed: {}, reconnect & retry", err);
                self.imap.trigger_reconnect();
-                if let Err(err) = self.connect_and_fetch(context) {
+                if let Err(err) = self.connect_and_fetch(context).await {
                    warn!(context, "connect+fetch failed: {}", err);
                }
            }
@@ -97,14 +97,18 @@ impl JobThread {
        self.state.0.lock().unwrap().using_handle = false;
    }

-    fn connect_and_fetch(&mut self, context: &Context) -> Result<()> {
+    async fn connect_and_fetch(&mut self, context: &Context) -> Result<()> {
        let prefix = format!("{}-fetch", self.name);
        match self.imap.connect_configured(context) {
            Ok(()) => {
                if let Some(watch_folder) = self.get_watch_folder(context) {
                    let start = std::time::Instant::now();
                    info!(context, "{} started...", prefix);
-                    let res = self.imap.fetch(context, &watch_folder).map_err(Into::into);
+                    let res = self
+                        .imap
+                        .fetch(context, &watch_folder)
+                        .await
+                        .map_err(Into::into);
                    let elapsed = start.elapsed().as_millis();
                    info!(context, "{} done in {:.3} ms.", prefix, elapsed);

@@ -170,20 +174,19 @@ impl JobThread {
        let prefix = format!("{}-IDLE", self.name);
        let do_fake_idle = match self.imap.connect_configured(context) {
            Ok(()) => {
-                info!(context, "{} started...", prefix);
-                let watch_folder = self.get_watch_folder(context);
-                let res = self.imap.idle(context, watch_folder);
-                info!(context, "{} ended...", prefix);
-                match res {
-                    Ok(()) => false,
-                    Err(crate::imap::Error::IdleAbilityMissing) => true, // we have to do fake_idle
-                    Err(err) => {
+                if !self.imap.can_idle() {
+                    true // we have to do fake_idle
+                } else {
+                    let watch_folder = self.get_watch_folder(context);
+                    info!(context, "{} started...", prefix);
+                    let res = self.imap.idle(context, watch_folder);
+                    info!(context, "{} ended...", prefix);
+                    if let Err(err) = res {
                        warn!(context, "{} failed: {} -> reconnecting", prefix, err);
                        // something is borked, let's start afresh on the next occassion
                        self.imap.disconnect(context);
-
-                        false
                    }
+                    false
                }
            }
            Err(err) => {
--- a/src/key.rs
+++ b/src/key.rs
@@ -178,20 +178,9 @@ impl Key {
        }
    }

-    pub fn to_base64(&self, break_every: usize) -> String {
+    pub fn to_base64(&self) -> String {
        let buf = self.to_bytes();
-
-        let encoded = base64::encode(&buf);
-        encoded
-            .chars()
-            .enumerate()
-            .fold(String::new(), |mut res, (i, c)| {
-                if i > 0 && i % break_every == 0 {
-                    res.push(' ')
-                }
-                res.push(c);
-                res
-            })
+        base64::encode(&buf)
    }

    pub fn to_armored_string(
--- a/src/mimefactory.rs
+++ b/src/mimefactory.rs
@@ -525,6 +525,12 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
                outer_message = outer_message.header(header);
            }

+            if std::env::var(crate::DCC_MIME_DEBUG).is_ok() {
+                info!(self.context, "mimefactory: outgoing message mime:");
+                let raw_message = message.clone().build().as_string();
+                println!("{}", raw_message);
+            }
+
            let encrypted =
                encrypt_helper.encrypt(self.context, min_verified, message, &peerstates)?;

--- a/src/mimeparser.rs
+++ b/src/mimeparser.rs
@@ -2,7 +2,7 @@ use std::collections::{HashMap, HashSet};

 use deltachat_derive::{FromSql, ToSql};
 use lettre_email::mime::{self, Mime};
-use mailparse::MailHeaderMap;
+use mailparse::{DispositionType, MailHeaderMap};

 use crate::aheader::Aheader;
 use crate::blob::BlobObject;
@@ -22,6 +22,7 @@ use crate::param::*;
 use crate::peerstate::Peerstate;
 use crate::securejoin::handle_degrade_event;
 use crate::stock::StockMessage;
+use crate::{bail, ensure};

 #[derive(Debug)]
 pub struct MimeParser<'a> {
@@ -29,7 +30,6 @@ pub struct MimeParser<'a> {
    pub parts: Vec<Part>,
    pub header: HashMap<String, String>,
    pub subject: Option<String>,
-    pub is_send_by_messenger: bool,
    pub decrypting_failed: bool,
    pub encrypted: bool,
    pub signatures: HashSet<String>,
@@ -74,7 +74,6 @@ impl<'a> MimeParser<'a> {
            parts: Vec::new(),
            header: Default::default(),
            subject: None,
-            is_send_by_messenger: false,
            decrypting_failed: false,
            encrypted: false,
            signatures: Default::default(),
@@ -109,6 +108,10 @@ impl<'a> MimeParser<'a> {
                if let Some(raw) = raw {
                    mail_raw = raw;
                    let decrypted_mail = mailparse::parse_mail(&mail_raw)?;
+                    if std::env::var(crate::DCC_MIME_DEBUG).is_ok() {
+                        info!(context, "decrypted message mime-body:");
+                        println!("{}", String::from_utf8_lossy(&mail_raw));
+                    }

                    // Handle any gossip headers if the mail was encrypted.  See section
                    // "3.6 Key Gossip" of https://autocrypt.org/autocrypt-spec-1.1.0.pdf
@@ -148,10 +151,6 @@ impl<'a> MimeParser<'a> {
            self.subject = Some(field.clone());
        }

-        if self.lookup_field("Chat-Version").is_some() {
-            self.is_send_by_messenger = true
-        }
-
        if self.lookup_field("Autocrypt-Setup-Message").is_some() {
            let has_setup_file = self.parts.iter().any(|p| {
                p.mimetype.is_some() && p.mimetype.as_ref().unwrap().as_ref() == MIME_AC_SETUP_FILE
@@ -198,7 +197,7 @@ impl<'a> MimeParser<'a> {
            }
        }

-        if self.is_send_by_messenger && self.parts.len() == 2 {
+        if self.has_chat_version() && self.parts.len() == 2 {
            let need_drop = {
                let textpart = &self.parts[0];
                let filepart = &self.parts[1];
@@ -232,7 +231,7 @@ impl<'a> MimeParser<'a> {
                let colon = subject.find(':');
                if colon == Some(2)
                    || colon == Some(3)
-                    || self.is_send_by_messenger
+                    || self.has_chat_version()
                    || subject.contains("Chat:")
                {
                    prepend_subject = 0i32
@@ -318,7 +317,7 @@ impl<'a> MimeParser<'a> {
            part.typ = Viewtype::Text;

            if let Some(ref subject) = self.subject {
-                if !self.is_send_by_messenger {
+                if !self.has_chat_version() {
                    part.msg = subject.to_string();
                }
            }
@@ -337,6 +336,10 @@ impl<'a> MimeParser<'a> {
        self.parts.iter_mut().rev().find(|part| !part.is_meta)
    }

+    pub(crate) fn has_chat_version(&self) -> bool {
+        self.header.contains_key("chat-version")
+    }
+
    pub fn lookup_field(&self, field_name: &str) -> Option<&String> {
        self.header.get(&field_name.to_lowercase())
    }
@@ -487,41 +490,10 @@ impl<'a> MimeParser<'a> {
                }
            }
            _ => {
-                // Add all parts (in fact,
-                // AddSinglePartIfKnown() later check if the parts are really supported)
-                // HACK: the following lines are a hack for clients who use
-                // multipart/mixed instead of multipart/alternative for
-                // combined text/html messages (eg. Stock Android "Mail" does so).
-                // So, if we detect such a message below, we skip the Html
-                // part.  However, not sure, if there are useful situations to use
-                // plain+html in multipart/mixed - if so, we should disable the hack.
-                let mut skip_part = -1;
-                let mut html_part = -1;
-                let mut plain_cnt = 0;
-                let mut html_cnt = 0;
-
-                for (i, cur_data) in mail.subparts.iter().enumerate() {
-                    match get_mime_type(cur_data)?.0.type_() {
-                        mime::TEXT => {
-                            plain_cnt += 1;
-                        }
-                        mime::HTML => {
-                            html_part = i as isize;
-                            html_cnt += 1;
-                        }
-                        _ => {}
-                    }
-                }
-                if plain_cnt == 1 && html_cnt == 1 {
-                    warn!(
-                        self.context,
-                        "HACK: multipart/mixed message found with Plain and HTML, we\'ll skip the HTML part as this seems to be unwanted."
-                    );
-                    skip_part = html_part;
-                }
-
-                for (i, cur_data) in mail.subparts.iter().enumerate() {
-                    if i as isize != skip_part && self.parse_mime_recursive(cur_data)? {
+                // Add all parts (in fact, AddSinglePartIfKnown() later check if
+                // the parts are really supported)
+                for cur_data in mail.subparts.iter() {
+                    if self.parse_mime_recursive(cur_data)? {
                        any_part_added = true;
                    }
                }
@@ -536,84 +508,60 @@ impl<'a> MimeParser<'a> {
        let (mime_type, msg_type) = get_mime_type(mail)?;
        let raw_mime = mail.ctype.mimetype.to_lowercase();

+        let filename = get_attachment_filename(mail);
+        info!(
+            self.context,
+            "add_single_part_if_known {:?} {:?} {:?}", mime_type, msg_type, filename
+        );
+
        let old_part_count = self.parts.len();

-        // regard `Content-Transfer-Encoding:`
-        match mime_type.type_() {
-            mime::TEXT | mime::HTML => {
-                let decoded_data = match mail.get_body() {
-                    Ok(decoded_data) => decoded_data,
-                    Err(err) => {
-                        warn!(self.context, "Invalid body parsed {:?}", err);
-                        // Note that it's not always an error - might be no data
-                        return Ok(false);
-                    }
-                };
-
-                // check header directly as is_send_by_messenger is not yet set up
-                let is_msgrmsg = self.lookup_field("Chat-Version").is_some();
-
-                let mut simplifier = Simplify::new();
-                let simplified_txt = if decoded_data.is_empty() {
-                    "".into()
-                } else {
-                    let is_html = mime_type == mime::TEXT_HTML;
-                    simplifier.simplify(&decoded_data, is_html, is_msgrmsg)
-                };
-
-                if !simplified_txt.is_empty() {
-                    let mut part = Part::default();
-                    part.typ = Viewtype::Text;
-                    part.mimetype = Some(mime_type);
-                    part.msg = simplified_txt;
-                    part.msg_raw = Some(decoded_data);
-                    self.do_add_single_part(part);
+        if let Ok(filename) = filename {
+            self.do_add_single_file_part(
+                msg_type,
+                mime_type,
+                &raw_mime,
+                &mail.get_body_raw()?,
+                &filename,
+            );
+        } else {
+            match mime_type.type_() {
+                mime::IMAGE | mime::AUDIO | mime::VIDEO | mime::APPLICATION => {
+                    bail!("missing attachment");
                }
+                mime::TEXT | mime::HTML => {
+                    let decoded_data = match mail.get_body() {
+                        Ok(decoded_data) => decoded_data,
+                        Err(err) => {
+                            warn!(self.context, "Invalid body parsed {:?}", err);
+                            // Note that it's not always an error - might be no data
+                            return Ok(false);
+                        }
+                    };

-                if simplifier.is_forwarded {
-                    self.is_forwarded = true;
-                }
-            }
-            mime::IMAGE | mime::AUDIO | mime::VIDEO | mime::APPLICATION => {
-                // try to get file name from
-                //    `Content-Disposition: ... filename*=...`
-                // or `Content-Disposition: ... filename*0*=... filename*1*=... filename*2*=...`
-                // or `Content-Disposition: ... filename=...`
-
-                let ct = mail.get_content_disposition()?;
-                let mut desired_filename = ct
-                    .params
-                    .iter()
-                    .filter(|(key, _value)| key.starts_with("filename"))
-                    .fold(String::new(), |mut acc, (_key, value)| {
-                        acc += value;
-                        acc
-                    });
-
-                if desired_filename.is_empty() {
-                    if let Some(param) = ct.params.get("name") {
-                        // might be a wrongly encoded filename
-                        desired_filename = param.to_string();
-                    }
-                }
-
-                // if there is still no filename, guess one
-                if desired_filename.is_empty() {
-                    if let Some(subtype) = mail.ctype.mimetype.split('/').nth(1) {
-                        desired_filename = format!("file.{}", subtype,);
+                    let mut simplifier = Simplify::new();
+                    let simplified_txt = if decoded_data.is_empty() {
+                        "".into()
                    } else {
-                        return Ok(false);
+                        let is_html = mime_type == mime::TEXT_HTML;
+                        simplifier.simplify(&decoded_data, is_html, self.has_chat_version())
+                    };
+
+                    if !simplified_txt.is_empty() {
+                        let mut part = Part::default();
+                        part.typ = Viewtype::Text;
+                        part.mimetype = Some(mime_type);
+                        part.msg = simplified_txt;
+                        part.msg_raw = Some(decoded_data);
+                        self.do_add_single_part(part);
+                    }
+
+                    if simplifier.is_forwarded {
+                        self.is_forwarded = true;
                    }
                }
-                self.do_add_single_file_part(
-                    msg_type,
-                    mime_type,
-                    &raw_mime,
-                    &mail.get_body_raw()?,
-                    &desired_filename,
-                );
+                _ => {}
            }
-            _ => {}
        }

        // add object? (we do not add all objects, eg. signatures etc. are ignored)
@@ -662,6 +610,7 @@ impl<'a> MimeParser<'a> {
                return;
            }
        };
+        info!(self.context, "added blobfile: {:?}", blob.as_name());

        /* create and register Mime part referencing the new Blob object */
        let mut part = Part::default();
@@ -812,11 +761,11 @@ impl<'a> MimeParser<'a> {
                mdn_consumed = true;
            }

-            if self.is_send_by_messenger || mdn_consumed {
+            if self.has_chat_version() || mdn_consumed {
                let mut param = Params::new();
                param.set(Param::ServerFolder, server_folder.as_ref());
                param.set_int(Param::ServerUid, server_uid as i32);
-                if self.is_send_by_messenger && self.context.get_config_bool(Config::MvboxMove) {
+                if self.has_chat_version() && self.context.get_config_bool(Config::MvboxMove) {
                    param.set_int(Param::AlsoMove, 1);
                }
                job_add(self.context, Action::MarkseenMdnOnImap, 0, param, 0);
@@ -913,12 +862,13 @@ pub struct Part {
    pub param: Params,
 }

+/// return mimetype and viewtype for a parsed mail
 fn get_mime_type(mail: &mailparse::ParsedMail<'_>) -> Result<(Mime, Viewtype)> {
    let mimetype = mail.ctype.mimetype.parse::<Mime>()?;

    let viewtype = match mimetype.type_() {
        mime::TEXT => {
-            if !mailmime_is_attachment_disposition(mail) {
+            if !is_attachment_disposition(mail) {
                match mimetype.subtype() {
                    mime::PLAIN | mime::HTML => Viewtype::Text,
                    _ => Viewtype::File,
@@ -952,14 +902,62 @@ fn get_mime_type(mail: &mailparse::ParsedMail<'_>) -> Result<(Mime, Viewtype)> {
    Ok((mimetype, viewtype))
 }

-fn mailmime_is_attachment_disposition(mail: &mailparse::ParsedMail<'_>) -> bool {
-    if let Some(ct) = mail.ctype.params.get("Content-Disposition") {
-        return ct.to_lowercase().starts_with("attachment");
+fn is_attachment_disposition(mail: &mailparse::ParsedMail<'_>) -> bool {
+    if let Ok(ct) = mail.get_content_disposition() {
+        return ct.disposition == DispositionType::Attachment
+            && ct
+                .params
+                .iter()
+                .any(|(key, _value)| key.starts_with("filename"));
    }

    false
 }

+fn get_attachment_filename(mail: &mailparse::ParsedMail) -> Result<String> {
+    // try to get file name from
+    //    `Content-Disposition: ... filename*=...`
+    // or `Content-Disposition: ... filename*0*=... filename*1*=... filename*2*=...`
+    // or `Content-Disposition: ... filename=...`
+
+    let ct = mail.get_content_disposition()?;
+    ensure!(
+        ct.disposition == DispositionType::Attachment,
+        "disposition not an attachment: {:?}",
+        ct.disposition
+    );
+
+    let mut desired_filename = ct
+        .params
+        .iter()
+        .filter(|(key, _value)| key.starts_with("filename"))
+        .fold(String::new(), |mut acc, (_key, value)| {
+            acc += value;
+            acc
+        });
+    println!("get_attachment_filename1: {:?}", desired_filename);
+
+    if desired_filename.is_empty() {
+        if let Some(param) = ct.params.get("name") {
+            // might be a wrongly encoded filename
+            desired_filename = param.to_string();
+        }
+    }
+    println!("get_attachment_filename2: {:?}", desired_filename);
+
+    // if there is still no filename, guess one
+    if desired_filename.is_empty() {
+        if let Some(subtype) = mail.ctype.mimetype.split('/').nth(1) {
+            desired_filename = format!("file.{}", subtype,);
+        } else {
+            bail!("could not determine filename: {:?}", ct.disposition);
+        }
+    }
+    println!("get_attachment_filename3: {:?}", desired_filename);
+
+    Ok(desired_filename)
+}
+
 // returned addresses are normalized.
 fn get_recipients<S: AsRef<str>, T: Iterator<Item = (S, S)>>(headers: T) -> HashSet<String> {
    let mut recipients: HashSet<String> = Default::default();
@@ -1064,6 +1062,29 @@ mod tests {
        assert_eq!(recipients.len(), 2);
    }

+    #[test]
+    fn test_is_attachment() {
+        let raw = include_bytes!("../test-data/message/mail_with_cc.txt");
+        let mail = mailparse::parse_mail(raw).unwrap();
+        assert!(!is_attachment_disposition(&mail));
+
+        let raw = include_bytes!("../test-data/message/mail_attach_txt.eml");
+        let mail = mailparse::parse_mail(raw).unwrap();
+        assert!(!is_attachment_disposition(&mail));
+        assert!(!is_attachment_disposition(&mail.subparts[0]));
+        assert!(is_attachment_disposition(&mail.subparts[1]));
+    }
+
+    #[test]
+    fn test_get_attachment_filename() {
+        let raw = include_bytes!("../test-data/message/html_attach.eml");
+        let mail = mailparse::parse_mail(raw).unwrap();
+        assert!(get_attachment_filename(&mail).is_err());
+        assert!(get_attachment_filename(&mail.subparts[0]).is_err());
+        let filename = get_attachment_filename(&mail.subparts[1]).unwrap();
+        assert_eq!(filename, "test.html")
+    }
+
    #[test]
    fn test_mailparse_content_type() {
        let ctype =
--- a/src/smtp/mod.rs
+++ b/src/smtp/mod.rs
@@ -5,8 +5,6 @@ pub mod send;
 use lettre::smtp::client::net::*;
 use lettre::*;

-use failure::Fail;
-
 use crate::constants::*;
 use crate::context::Context;
 use crate::events::Event;
--- a/src/sql.rs
+++ b/src/sql.rs
@@ -1,7 +1,5 @@
 //! # SQLite wrapper

-use failure::Fail;
-
 use std::collections::HashSet;
 use std::sync::{Arc, RwLock};
 use std::time::Duration;
--- a/test-data/message/html_attach.eml
+++ b/test-data/message/html_attach.eml
@@ -0,0 +1,25 @@
+Chat-Disposition-Notification-To: tmp_6272287793210918@testrun.org
+Subject: =?utf-8?q?Chat=3A_File_=E2=80=93_test=2Ehtml?=
+Message-ID: Mr.XA6y3og8-az.WGbH9_dNcQx@testrun.org
+Date: Sat, 07 Dec 2019 19:00:27 +0000
+X-Mailer: Delta Chat Core 1.0.0-beta.12/DcFFI
+Chat-Version: 1.0
+To: <tmp_5890965001269692@testrun.org>
+From: "=?utf-8?q??=" <tmp_6272287793210918@testrun.org>
+Content-Type: multipart/mixed; boundary="mwkNRwaJw1M5n2xcr2ODfAqvTjcj9Z"
+
+
+--mwkNRwaJw1M5n2xcr2ODfAqvTjcj9Z
+Content-Type: text/plain; charset=utf-8
+
+-- 
+Sent with my Delta Chat Messenger: https://delta.chat
+
+--mwkNRwaJw1M5n2xcr2ODfAqvTjcj9Z
+Content-Type: text/html
+Content-Disposition: attachment; filename="test.html"
+Content-Transfer-Encoding: base64
+
+PGh0bWw+PGJvZHk+dGV4dDwvYm9keT5kYXRh
+
+--mwkNRwaJw1M5n2xcr2ODfAqvTjcj9Z--
--- a/test-data/message/mail_attach_txt.eml
+++ b/test-data/message/mail_attach_txt.eml
@@ -0,0 +1,40 @@
+From holger@merlinux.eu Sat Dec  7 11:53:58 2019
+Return-Path: <holger@merlinux.eu>
+X-Original-To: holger+test@merlinux.eu
+Delivered-To: holger+test@merlinux.eu
+Received: from [127.0.0.1] (localhost [127.0.0.1])
+	(using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits))
+	(No client certificate requested)
+	by mail.merlinux.eu (Postfix) with ESMTPSA id 61825100531;
+	Sat,  7 Dec 2019 10:53:58 +0000 (UTC)
+DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=merlinux.eu;
+	s=default; t=1575716038;
+	bh=xhaPssQzVOHRafcciTQqDnZ1Zi4GMwsmg9pHLH3i8P8=;
+	h=Date:From:To:Subject;
+	b=U4HxGDZ8RwLwRPFtIvRsb+x5BiyICnbbY2ZOGlZdLt12MuDTfiYi/phHiQUC402EY
+	 GXb8dYgYr5+0PDiPBa7dyt2VQLC/h9QRfOA82tb1vpJYC+KksSAH0nYQqJvs7XrqCN
+	 i95/jwZnsWrV7w72+xsrO5qPujIE68TmM5I9Cyec=
+Received: by beto.merlinux.eu (Postfix, from userid 1000)
+	id 229D3820070; Sat,  7 Dec 2019 11:53:58 +0100 (CET)
+Date: Sat, 7 Dec 2019 11:53:57 +0100
+From: holger krekel <holger@merlinux.eu>
+To: holger+test@merlinux.eu
+Subject: hello
+Message-ID: <20191207105357.GA6266@beto>
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary="YiEDa0DAkWCtVeE4"
+Content-Disposition: inline
+
+--YiEDa0DAkWCtVeE4
+Content-Type: text/plain; charset=us-ascii
+Content-Disposition: inline
+
+siehe anhang
+
+--YiEDa0DAkWCtVeE4
+Content-Type: text/plain; charset=us-ascii
+Content-Disposition: attachment; filename="x.txt"
+
+hello
+
+--YiEDa0DAkWCtVeE4--
Author	SHA1	Message	Date
holger krekel	0dc87e9a0f	remove one attr from mimeparser	2019-12-07 22:41:43 +01:00
holger krekel	c011a8cfef	run lint without installing the package	2019-12-07 21:44:34 +01:00
holger krekel	2d7d79fc44	allow to use a different buildhost :)	2019-12-07 21:44:34 +01:00
holger krekel	119d4fa689	- test and fix receiving text/html attachment in multipart/mixed situations They are now preserved as attachment, instead of diving into parsing-html and simplifying. - adapt mime-debugging	2019-12-07 21:44:34 +01:00
holger krekel	b7a9f73329	passes test but needs cleanup	2019-12-07 21:44:34 +01:00
holger krekel	a52a3e0d24	try fix incoming text/html in multipart/mixed	2019-12-07 21:44:34 +01:00
Alexander Krotov	f32876708a	Update outdated comment MIME wrapping is now done by the email crate, which implements RFC5322	2019-12-07 21:35:42 +01:00
Alexander Krotov	84e0e7e020	aheader.rs: do not generate lines longer than 78 characters	2019-12-07 21:35:42 +01:00
Alexander Krotov	38cddff6e9	Move keydata= wrapping from key.rs to aheader.rs	2019-12-07 21:35:42 +01:00
Alexander Krotov	f1aba8115b	Use Option<EncryptPreference>.unwrap_or_default in aheader.rs	2019-12-07 07:58:53 +01:00
B. Petersen	0db5ff55fd	unshape icons, used indexed colors	2019-12-06 20:10:19 +01:00
B. Petersen	7421b0de6c	adapt the ffi-examples to reality, free stuff	2019-12-06 20:08:57 +01:00
Alexander Krotov	6c275c30a7	Do not include "prefer-encrypt=nopreference;" in Autocrypt header Specification https://autocrypt.org/level1.html#the-autocrypt-header says that prefer-encrypt attribute can only occur with the value `mutual`.	2019-12-06 20:01:34 +03:00
Alexander Krotov	91f1d793e9	Test that internal "prefer-encrypt=reset" value is not parsed from header This is a test for bugfix `e8f2f7b24e`	2019-12-06 14:23:45 +01:00
Alexander Krotov	cddfd04a7f	Turn rawkey from function into a constant	2019-12-06 14:23:45 +01:00
Alexander Krotov	7fa94c33bf	cargo fmt	2019-12-06 10:35:02 +01:00
Alexander Krotov	30dd20dc7b	Make Imap.fetch() async	2019-12-06 10:35:02 +01:00
Alexander Krotov	339c0d3dc7	Remove unnecessary use of failure::Fail	2019-12-06 10:34:34 +01:00
Alexander Krotov	2304d63bb3	Simplify dc_get_filesuffix_lc	2019-12-06 09:45:24 +01:00
holger krekel	36014f9fe5	add next changelog entry	2019-12-06 09:00:23 +01:00
Alexander Krotov	351383dfa4	Split IMAP idle functions into imap::idle submodule Also introduce Imap.can_idle() to avoid having to match on IdleAbilityMissing error	2019-12-06 08:59:22 +01:00
holger krekel	defad94f5a	bump to beta12	2019-12-06 00:55:24 +01:00
holger krekel	a0517478e3	adding auto-copy-blob logic when preparing a message	2019-12-06 00:27:22 +01:00
holger krekel	7f4e68f21c	failing test for sending out a file twice	2019-12-06 00:27:22 +01:00
holger krekel	c0a425c26d	bump to beta11	2019-12-05 21:53:03 +01:00
holger krekel	e756859b16	don't split qr tests out anymore now	2019-12-05 21:50:17 +01:00
holger krekel	174bc017ad	make setup_handle_if_needed async, call it ahead of select_folder and fetch_new_messages (renamed from fetch_from_single_folder), and be more eager triggering reconnect on error conditions	2019-12-05 21:47:32 +01:00