do not disconnect sentbox and mvbox, they would be connected at once as no longer suspended

remove thread-suspend
job: try_again refactoring
2026-06-28 18:46:35 +03:00 · 2019-11-27 14:53:27 +01:00 · 2019-11-27 00:06:32 +01:00 · 2019-11-26 22:14:34 +01:00 · 2019-11-25 12:59:55 +01:00 · 2019-11-25 12:59:55 +01:00
59 changed files with 3309 additions and 2070 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -15,7 +15,7 @@ restore-workspace: &restore-workspace
 restore-cache: &restore-cache
  restore_cache:
    keys:
-      - cargo-v2-{{ checksum "rust-toolchain" }}-{{ checksum "Cargo.toml" }}-{{ checksum "Cargo.lock" }}-{{ arch }}
+      - cargo-v3-{{ checksum "rust-toolchain" }}-{{ checksum "Cargo.toml" }}-{{ checksum "Cargo.lock" }}-{{ arch }}
      - repo-source-{{ .Branch }}-{{ .Revision }}

 commands:
@@ -44,7 +44,7 @@ jobs:
          command: cargo generate-lockfile
      - restore_cache:
          keys:
-            - cargo-v2-{{ checksum "rust-toolchain" }}-{{ checksum "Cargo.toml" }}-{{ checksum "Cargo.lock" }}-{{ arch }}
+            - cargo-v3-{{ checksum "rust-toolchain" }}-{{ checksum "Cargo.toml" }}-{{ checksum "Cargo.lock" }}-{{ arch }}
      - run: rustup install $(cat rust-toolchain)
      - run: rustup default $(cat rust-toolchain)
      - run: rustup component add --toolchain $(cat rust-toolchain) rustfmt
@@ -60,7 +60,7 @@ jobs:
          paths:
            - crate
      - save_cache:
-          key: cargo-v2-{{ checksum "rust-toolchain" }}-{{ checksum "Cargo.toml" }}-{{ checksum "Cargo.lock" }}-{{ arch }}
+          key: cargo-v3-{{ checksum "rust-toolchain" }}-{{ checksum "Cargo.toml" }}-{{ checksum "Cargo.lock" }}-{{ arch }}
          paths:
            - "~/.cargo"
            - "~/.rustup"
@@ -121,39 +121,54 @@ jobs:
    steps:
      - checkout
      - run: bash ci_scripts/run-doxygen.sh
-      - run: mkdir -p workspace/c-docs 
+      - run: mkdir -p workspace/c-docs
      - run: cp -av deltachat-ffi/{html,xml} workspace/c-docs/
      - persist_to_workspace:
          root: workspace
          paths:
            - c-docs

-  build_test_docs_wheel:
-    docker:
-      - image: deltachat/coredeps
-        environment:
-            TESTS: 1
-            DOCS: 1
-    working_directory: /mnt/crate
+  # build_test_docs_wheel:
+  #   docker:
+  #     - image: deltachat/coredeps
+  #       environment:
+  #           TESTS: 1
+  #           DOCS: 1
+  #   working_directory: /mnt/crate
+  #   steps:
+  #     - *restore-workspace
+  #     - *restore-cache
+  #     - run:
+  #         name: build docs, run tests and build wheels
+  #         command: ci_scripts/run-python.sh
+  #     - run:
+  #          name: copying docs and wheels to workspace
+  #          command: |
+  #            mkdir -p workspace/python
+  #            # cp -av docs workspace/c-docs
+  #            cp -av python/.docker-tox/wheelhouse workspace/
+  #            cp -av python/doc/_build/ workspace/py-docs
+  #     - persist_to_workspace:
+  #         root: workspace
+  #         paths:
+  #           # - c-docs
+  #           - py-docs
+  #           - wheelhouse
+
+  remote_tests_rust:
+    machine: true
    steps:
-      - *restore-workspace
-      - *restore-cache
-      - run:
-          name: build docs, run tests and build wheels
-          command: ci_scripts/run-python.sh
-      - run:
-           name: copying docs and wheels to workspace
-           command: |
-             mkdir -p workspace/python
-             # cp -av docs workspace/c-docs
-             cp -av python/.docker-tox/wheelhouse workspace/
-             cp -av python/doc/_build/ workspace/py-docs
-      - persist_to_workspace:
-          root: workspace
-          paths:
-            # - c-docs
-            - py-docs
-            - wheelhouse
+      - checkout
+      - run: ci_scripts/remote_tests_rust.sh
+    
+  remote_tests_python:
+    machine: true
+    steps:
+      - checkout
+      #- attach_workspace:
+      #    at: workspace
+      - run: ci_scripts/remote_tests_python.sh
+    # workspace/py-docs workspace/wheelhouse workspace/c-docs

  upload_docs_wheels:
    machine: true
@@ -181,15 +196,15 @@ workflows:
  test:
    jobs:
      - cargo_fetch
-      - build_doxygen

-      - build_test_docs_wheel:
-          requires:
-            - cargo_fetch
-      - upload_docs_wheels:
-          requires:
-            - build_test_docs_wheel
-            - build_doxygen 
+      - remote_tests_rust
+
+      - remote_tests_python
+
+      # - upload_docs_wheels:
+      #     requires:
+      #       - build_test_docs_wheel
+      #       - build_doxygen
      - rustfmt:
          requires:
            - cargo_fetch
@@ -197,10 +212,12 @@ workflows:
          requires:
           - cargo_fetch

+      - build_doxygen
+
      # Linux Desktop 64bit
-      - test_x86_64-unknown-linux-gnu:
-          requires:
-            - cargo_fetch
+      # - test_x86_64-unknown-linux-gnu:
+      #     requires:
+      #       - cargo_fetch

      # Linux Desktop 32bit
      # - test_i686-unknown-linux-gnu:
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -1,15 +0,0 @@
-name: Rust
-
-on: [push]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v1
-    - name: Build
-      run: cargo build --verbose
-    - name: Run tests
-      run: cargo test --verbose
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,37 @@
 # Changelog 

+## 1.0.0-beta.8
+
+- now uses async-email/async-imap as the new base 
+  which makes imap-idle interruptible and thus fixes
+  several issues around the imap thread being in zombie state . 
+  thanks @dignifiedquire, @hpk42 and @link2xt. 
+
+- fixes imap-protocol parsing bugs that lead to infinitely
+  repeated crashing while trying to receive messages with
+  a subjec that contained non-utf8. thanks @link2xt
+
+- fixed logic to find encryption subkey -- previously 
+  delta chat would use the primary key for encryption
+  (which works with RSA but not ECC). thanks @link2xt
+
+- introduce a new device chat where core and UIs can 
+  add "device" messages.  Android uses it for an initial
+  welcome message. thanks @r10s
+
+- fix time smearing (when two message are virtually send
+  in the same second, there would be misbehaviour because
+  we didn't persist smeared time). thanks @r10s
+
+- fix double-dotted extensions like .html.zip or .tar.gz  
+  to not mangle them when creating blobfiles.  thanks @flub
+
+- fix backup/exports where the wrong sql file would be modified,
+  leading to problems when exporting twice.  thanks @hpk42
+
+- several other little fixes and improvements 
+
+
 ## 1.0.0-beta.7

 - fix location-streaming #782
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat"
-version = "1.0.0-beta.7"
+version = "1.0.0-beta.8"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"
 license = "MPL"
@@ -10,17 +10,18 @@ deltachat_derive = { path = "./deltachat_derive" }
 mmime = { version = "0.1.2", path = "./mmime" }

 libc = "0.2.51"
-pgp = { version = "0.2.3", default-features = false }
-hex = "0.3.2"
+pgp = { git = "https://github.com/rpgp/rpgp", branch = "master", default-features = false }
+hex = "0.4.0"
 sha2 = "0.8.0"
 rand = "0.6.5"
 smallvec = "0.6.9"
-reqwest = "0.9.15"
+reqwest = { version = "0.9.15", default-features = false, features = ["rustls-tls"] }
 num-derive = "0.2.5"
 num-traits = "0.2.6"
-native-tls = "0.2.3"
-lettre = { git = "https://github.com/deltachat/lettre", branch = "master" }
-imap = { git = "https://github.com/deltachat/rust-imap", branch = "master" }
+lettre = { git = "https://github.com/deltachat/lettre", branch = "feat/rustls" }
+async-imap = { git = "https://github.com/async-email/async-imap", branch="master" }
+async-tls = "0.6"
+async-std = { version = "1.0", features = ["unstable"] }
 base64 = "0.10"
 charset = "0.1"
 percent-encoding = "2.0"
@@ -49,7 +50,10 @@ bitflags = "1.1.0"
 jetscii = "0.4.4"
 debug_stub_derive = "0.3.0"
 sanitize-filename = "0.2.1"
-indoc = "0.3"
+stop-token = { version = "0.1.1", features = ["unstable"] }
+rustls = "0.16.0"
+webpki-roots = "0.18.0"
+webpki = "0.21.0"

 [dev-dependencies]
 tempfile = "3.0"
@@ -75,6 +79,6 @@ path = "examples/repl/main.rs"

 [features]
 default = ["nightly", "ringbuf"]
-vendored = ["native-tls/vendored", "reqwest/default-tls-vendored"]
+vendored = []
 nightly = ["pgp/nightly"]
 ringbuf = ["pgp/ringbuf"]
--- a/README.md
+++ b/README.md
@@ -1,11 +1,9 @@
 # Delta Chat Rust

-> Project porting deltachat-core to rust
+> Deltachat-core written in Rust 

 [![CircleCI build status][circle-shield]][circle] [![Appveyor build status][appveyor-shield]][appveyor]

-Current commit on deltachat/deltachat-core: `12ef73c8e76185f9b78e844ea673025f56a959ab`.
-
 ## Installing Rust and Cargo

 To download and install the official compiler for the Rust programming language, and the Cargo package manager, run the command in your user environment:
@@ -16,7 +14,7 @@ curl https://sh.rustup.rs -sSf | sh

 ## Using the CLI client

-Compile and run Delta Chat Core using `cargo`:
+Compile and run Delta Chat Core command line utility, using `cargo`:

 ```
 cargo run --example repl -- /path/to/db
--- a/assets/icon-device.png
+++ b/assets/icon-device.png
--- a/assets/icon-device.svg
+++ b/assets/icon-device.svg
@@ -0,0 +1,110 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:xlink="http://www.w3.org/1999/xlink"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   inkscape:version="1.0beta1 (32d4812, 2019-09-19)"
+   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="/Users/bpetersen/Documents/deltachat/icons/device4.png"
+   inkscape:export-xdpi="96"
+   inkscape:export-ydpi="96">
+  <defs
+     id="defs4348">
+    <linearGradient
+       inkscape:collect="always"
+       id="linearGradient865">
+      <stop
+         style="stop-color:#364e59;stop-opacity:1;"
+         offset="0"
+         id="stop861" />
+      <stop
+         style="stop-color:#ffffff;stop-opacity:1"
+         offset="1"
+         id="stop863" />
+    </linearGradient>
+    <linearGradient
+       inkscape:collect="always"
+       xlink:href="#linearGradient865"
+       id="linearGradient867"
+       x1="10.227795"
+       y1="43.5238"
+       x2="-25.458139"
+       y2="-7.4257693"
+       gradientUnits="userSpaceOnUse" />
+  </defs>
+  <sodipodi:namedview
+     inkscape:current-layer="svg4344"
+     inkscape:window-maximized="0"
+     inkscape:window-y="23"
+     inkscape:window-x="45"
+     inkscape:cy="28.471578"
+     inkscape:cx="41.455164"
+     inkscape:zoom="5.6"
+     units="px"
+     showgrid="false"
+     id="namedview4346"
+     inkscape:window-height="1035"
+     inkscape:window-width="1600"
+     inkscape:pageshadow="2"
+     inkscape:pageopacity="0"
+     guidetolerance="10"
+     gridtolerance="10"
+     objecttolerance="10"
+     borderopacity="1"
+     inkscape:document-rotation="0"
+     bordercolor="#666666"
+     pagecolor="#ffffff" />
+  <metadata
+     id="metadata4336">
+Created by potrace 1.15, written by Peter Selinger 2001-2017
+<rdf:RDF>
+  <cc:Work
+     rdf:about="">
+    <dc:format>image/svg+xml</dc:format>
+    <dc:type
+       rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+    <dc:title />
+  </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:url(#linearGradient867);fill-opacity:1;stroke-width:0.588554" />
+  <g
+     id="g4342"
+     stroke="none"
+     fill="#000000"
+     transform="matrix(0.00255113,0,0,-0.00255113,5.586152,38.200477)"
+     style="fill:#ffffff;fill-opacity:1">
+    <path
+       inkscape:connector-curvature="0"
+       id="path4338"
+       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" />
+    <path
+       inkscape:connector-curvature="0"
+       id="path4340"
+       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" />
+  </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
@@ -0,0 +1,99 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:xlink="http://www.w3.org/1999/xlink"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   inkscape:export-ydpi="204.8"
+   inkscape:export-xdpi="204.8"
+   inkscape:export-filename="/Users/bpetersen/Documents/deltachat/icons/saved-messages.png"
+   version="1.0"
+   width="60"
+   height="60"
+   viewBox="0 0 45 45"
+   preserveAspectRatio="xMidYMid meet"
+   id="svg4344"
+   sodipodi:docname="saved-messages.svg"
+   inkscape:version="1.0beta1 (32d4812, 2019-09-19)">
+  <defs
+     id="defs4348">
+    <linearGradient
+       inkscape:collect="always"
+       id="linearGradient906">
+      <stop
+         style="stop-color:#046cdb;stop-opacity:1"
+         offset="0"
+         id="stop902" />
+      <stop
+         id="stop845"
+         offset="1"
+         style="stop-color:#ffffff;stop-opacity:1" />
+    </linearGradient>
+    <linearGradient
+       y2="-11.049108"
+       x2="-3.1473193"
+       y1="31.473215"
+       x1="36.160713"
+       gradientUnits="userSpaceOnUse"
+       id="linearGradient847"
+       xlink:href="#linearGradient906"
+       inkscape:collect="always" />
+  </defs>
+  <sodipodi:namedview
+     pagecolor="#ffffff"
+     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="2.8"
+     inkscape:cx="48.214285"
+     inkscape:cy="55"
+     inkscape:window-x="45"
+     inkscape:window-y="23"
+     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
+<rdf:RDF>
+  <cc:Work
+     rdf:about="">
+    <dc:format>image/svg+xml</dc:format>
+    <dc:type
+       rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+    <dc:title />
+  </cc:Work>
+</rdf:RDF>
+</metadata>
+  <circle
+     r="22.5"
+     cy="22.5"
+     cx="22.5"
+     id="path859"
+     style="opacity:1;fill:#ffffff;fill-opacity:1;stroke-width:0.731071" />
+  <circle
+     style="fill:url(#linearGradient847);fill-opacity:1;stroke-width:0.588554"
+     id="path4917"
+     cx="22.5"
+     cy="22.5"
+     r="22.5" />
+  <path
+     id="rect846"
+     style="fill:#ffffff;stroke-width:0.84832"
+     d="M 17 9 L 17 55 L 17.125 55 L 30.048828 40.9375 L 42.974609 55 L 43 55 L 43 9 L 17 9 z M 30.005859 15 L 32.720703 22.121094 L 40 22.646484 L 34.396484 27.558594 L 36.169922 35 L 29.992188 30.916016 L 23.808594 34.988281 L 25.595703 27.550781 L 20 22.626953 L 27.28125 22.115234 L 30.005859 15 z "
+     transform="scale(0.75)" />
+</svg>
--- a/ci_scripts/README.md
+++ b/ci_scripts/README.md
@@ -1,52 +1,46 @@
-
 # Continuous Integration Scripts for Delta Chat

-Continuous Integration is run through CircleCI
-but is largely independent of it. 
+Continuous Integration, run through CircleCI and an own build machine.
+
+## Description of scripts 
+
+- `../.circleci/config.yml` describing the build jobs that are run
+  by Circle-CI
+
+- `remote_tests_python.sh` rsyncs to a build machine and runs
+  `run-python-test.sh` remotely on the build machine. 
+
+- `remote_tests_rust.sh` rsyncs to the build machine and runs
+  `run-rust-test.sh` remotely on the build machine. 
+
+- `doxygen/Dockerfile` specifies an image that contains
+  the doxygen tool which is used by `run-doxygen.sh` 
+  to generate C-docs which are then uploaded 
+  via `ci_upload.sh` to `https://c.delta.chat/_unofficial_unreleased_docs/<BRANCH>`
+  (and the master branch is linked to https://c.delta.chat proper). 


-## Generating docker containers for performing build step work 
+## Triggering runs on the build machine locally (fast!)

-All tests, docs and wheel building is run in docker containers:
+There is experimental support for triggering a remote Python or Rust test run 
+from your local checkout/branch. You will need to be authorized to login to 
+the build machine (ask your friendly sysadmin on #deltachat freenode) to type::

- **coredeps/Dockerfile** specifies an image that contains all 
-  of Delta Chat's core dependencies as linkable libraries. 
-  It also serves to run python tests and build wheels 
-  (binary packages for Python). 
+    ci_scripts/manual_remote_tests.sh rust
+    ci_scripts/manual_remote_tests.sh python

- **doxygen/Dockerfile** specifies an image that contains
-  the doxygen tool which is used to generate C-docs. 
+This will **rsync** your current checkout to the remote build machine 
+(no need to commit before) and then run either rust or python tests. 

-To run tests locally you can pull existing images from "docker.io",
-the hub for sharing Docker images::
+# Outdated files (for later re-use)

-    docker pull deltachat/coredeps
-    docker pull deltachat/doxygen 
+`coredeps/Dockerfile` specifies an image that contains all 
+of Delta Chat's core dependencies. It used to run 
+python tests and build wheels (binary packages for Python)

-or you can build the docker images yourself locally
+You can build the docker images yourself locally
 to avoid the relatively large download:: 
 
    cd ci_scripts  # where all CI things are 
    docker build -t deltachat/coredeps docker-coredeps
    docker build -t deltachat/doxygen docker-doxygen 
-
-## ci_run.sh (main entrypoint called by circle-ci)
-
-Once you have the docker images available 
-you can run python testing, documentation generation 
-and building binary wheels:: 
-
-    sh DOCS=1 TESTS=1 ci_scripts/ci_run.sh 
-    
-## ci_upload.sh (uploading artifacts on success) 
-
- python docs to `https://py.delta.chat/_unofficial_unreleased_docs/<BRANCH>`
-
- doxygen docs to `https://c.delta.chat/_unofficial_unreleased_docs/<BRANCH>`
-
- python wheels to `https://m.devpi.net/dc/<BRANCH>`
-  so that you install fully self-contained wheels like this:
-  `pip install -U -i https://m.devpi.net/dc/<BRANCH> deltachat`
-
-
-
--- a/ci_scripts/ci_upload.sh
+++ b/ci_scripts/ci_upload.sh
@@ -14,20 +14,24 @@ DOXYDOCDIR=${3:?directory where doxygen docs to be found}
 export BRANCH=${CIRCLE_BRANCH:?specify branch for uploading purposes}


-# python docs to py.delta.chat
-ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null delta@py.delta.chat mkdir -p build/${BRANCH}
-rsync -avz \
-  -e "ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null" \
-  "$PYDOCDIR/html/" \
-  delta@py.delta.chat:build/${BRANCH}
+# DISABLED: python docs to py.delta.chat
+#ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null delta@py.delta.chat mkdir -p build/${BRANCH}
+#rsync -avz \
+#  -e "ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null" \
+#  "$PYDOCDIR/html/" \
+#  delta@py.delta.chat:build/${BRANCH}

 # C docs to c.delta.chat
-ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null delta@c.delta.chat mkdir -p build-c/${BRANCH}
+ssh -o BatchMode=yes -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null delta@c.delta.chat mkdir -p build-c/${BRANCH}
 rsync -avz \
  -e "ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null" \
  "$DOXYDOCDIR/html/" \
  delta@c.delta.chat:build-c/${BRANCH}

+exit 0
+
+# OUTDATED -- for re-use from python release-scripts 
+
 echo -----------------------
 echo upload wheels 
 echo -----------------------
--- a/ci_scripts/docker-coredeps/Dockerfile
+++ b/ci_scripts/docker-coredeps/Dockerfile
@@ -5,16 +5,6 @@ RUN echo /usr/local/lib64 > /etc/ld.so.conf.d/local.conf && \
    echo /usr/local/lib >> /etc/ld.so.conf.d/local.conf
 ENV PKG_CONFIG_PATH /usr/local/lib64/pkgconfig:/usr/local/lib/pkgconfig

-ENV PIP_DISABLE_PIP_VERSION_CHECK 1
-
-# Install python tools (auditwheels,tox, ...)
-ADD deps/build_python.sh /builder/build_python.sh
-RUN mkdir tmp1 && cd tmp1 && bash /builder/build_python.sh && cd .. && rm -r tmp1
-
-# Install Rust nightly 
-ADD deps/build_rust.sh /builder/build_rust.sh
-RUN mkdir tmp1 && cd tmp1 && bash /builder/build_rust.sh && cd .. && rm -r tmp1
-
 # Install a recent Perl, needed to install OpenSSL
 ADD deps/build_perl.sh /builder/build_perl.sh
 RUN mkdir tmp1 && cd tmp1 && bash /builder/build_perl.sh && cd .. && rm -r tmp1
@@ -23,3 +13,12 @@ RUN mkdir tmp1 && cd tmp1 && bash /builder/build_perl.sh && cd .. && rm -r tmp1
 ADD deps/build_openssl.sh /builder/build_openssl.sh
 RUN mkdir tmp1 && cd tmp1 && bash /builder/build_openssl.sh && cd .. && rm -r tmp1

+ENV PIP_DISABLE_PIP_VERSION_CHECK 1
+
+# Install python tools (auditwheels,tox, ...)
+ADD deps/build_python.sh /builder/build_python.sh
+RUN mkdir tmp1 && cd tmp1 && bash /builder/build_python.sh && cd .. && rm -r tmp1
+
+# Install Rust nightly
+ADD deps/build_rust.sh /builder/build_rust.sh
+RUN mkdir tmp1 && cd tmp1 && bash /builder/build_rust.sh && cd .. && rm -r tmp1
--- a/ci_scripts/docker-coredeps/deps/build_perl.sh
+++ b/ci_scripts/docker-coredeps/deps/build_perl.sh
@@ -1,11 +1,11 @@
 #!/bin/bash

-PERL_VERSION=5.28.0
-PERL_SHA256=7e929f64d4cb0e9d1159d4a59fc89394e27fa1f7004d0836ca0d514685406ea8
+PERL_VERSION=5.30.0
+# PERL_SHA256=7e929f64d4cb0e9d1159d4a59fc89394e27fa1f7004d0836ca0d514685406ea8
 curl -O https://www.cpan.org/src/5.0/perl-${PERL_VERSION}.tar.gz
-echo "${PERL_SHA256}  perl-${PERL_VERSION}.tar.gz" | sha256sum -c -
-tar xzf perl-${PERL_VERSION}.tar.gz
-cd perl-${PERL_VERSION} 
+# echo "${PERL_SHA256}  perl-${PERL_VERSION}.tar.gz" | sha256sum -c -
+tar -xzf perl-${PERL_VERSION}.tar.gz
+cd perl-${PERL_VERSION}

 ./Configure -de
 make
--- a/ci_scripts/docker-coredeps/deps/build_rust.sh
+++ b/ci_scripts/docker-coredeps/deps/build_rust.sh
@@ -1,11 +1,8 @@
 #!/bin/bash

-set -e -x 
+set -e -x

-# Install Rust 
-curl https://sh.rustup.rs -sSf | sh -s -- --default-toolchain nightly-2019-07-10 -y
+# Install Rust
+curl https://sh.rustup.rs -sSf | sh -s -- --default-toolchain nightly-2019-09-12 -y
 export PATH=/root/.cargo/bin:$PATH
 rustc --version
-
-# remove some 300-400 MB that we don't need for automated builds
-rm -rf /root/.rustup/toolchains/nightly-2019-07-10-x86_64-unknown-linux-gnu/share/
--- a/ci_scripts/manual_remote_tests.sh
+++ b/ci_scripts/manual_remote_tests.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+set -xe
+export CIRCLE_JOB=remote_tests_${1:?need to specify 'rust' or 'python'} 
+export CIRCLE_BUILD_NUM=$USER
+export CIRCLE_BRANCH=`git branch | grep \* | cut -d ' ' -f2`
+export CIRCLE_PROJECT_REPONAME=$(basename `git rev-parse --show-toplevel`)
+
+time bash ci_scripts/$CIRCLE_JOB.sh 
--- a/ci_scripts/old/gh-actions-rust.yml
+++ b/ci_scripts/old/gh-actions-rust.yml
@@ -0,0 +1,77 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+
+env:
+  RUSTFLAGS: -Dwarnings
+
+jobs:
+  build_and_test:
+    name: Build and test
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macOS-latest]
+        rust: [nightly]
+
+    steps:
+    - uses: actions/checkout@master
+
+    - name: Install ${{ matrix.rust }}
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: ${{ matrix.rust }}
+        override: true
+
+    - name: check
+      uses: actions-rs/cargo@v1
+      if: matrix.rust == 'nightly'
+      with:
+        command:  check
+        args: --all --bins --examples --tests
+
+    - name: tests
+      uses: actions-rs/cargo@v1
+      with:
+        command: test
+        args: --all
+
+    - name: tests ignored
+      uses: actions-rs/cargo@v1
+      with:
+        command: test
+        args: --all --release -- --ignored
+
+  check_fmt:
+    name: Checking fmt and docs
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@master
+
+    - uses: actions-rs/toolchain@v1
+      with:
+          profile: minimal
+          toolchain: nightly
+          override: true
+          components: rustfmt
+
+    - name: fmt
+      run: cargo fmt --all -- --check
+
+#  clippy_check:
+#    name: Clippy check
+#    runs-on: ubuntu-latest
+#
+#    steps:
+#    - uses: actions/checkout@v1
+#    - uses: actions-rs/toolchain@v1
+#      with:
+#          profile: minimal
+#          toolchain: nightly
+#          override: true
+#          components: clippy
+#
+#    - name: clippy
+#      run: cargo clippy --all
--- a/ci_scripts/old/run-python.sh
+++ b/ci_scripts/old/run-python.sh
--- a/ci_scripts/remote_tests_python.sh
+++ b/ci_scripts/remote_tests_python.sh
@@ -0,0 +1,46 @@
+#!/bin/bash 
+
+export BRANCH=${CIRCLE_BRANCH:?branch to build}
+export REPONAME=${CIRCLE_PROJECT_REPONAME:?repository name}
+export SSHTARGET=ci@b1.delta.chat
+
+# we construct the BUILDDIR such that we can easily share the
+# CARGO_TARGET_DIR between runs ("..")
+export BUILDDIR=ci_builds/$REPONAME/$BRANCH/${CIRCLE_JOB:?jobname}/${CIRCLE_BUILD_NUM:?circle-build-number}
+
+echo "--- Copying files to $SSHTARGET:$BUILDDIR"
+
+set -xe
+
+ssh -oBatchMode=yes -oStrictHostKeyChecking=no  $SSHTARGET mkdir -p "$BUILDDIR"
+git ls-files >.rsynclist 
+# we seem to need .git for setuptools_scm versioning 
+find .git >>.rsynclist
+rsync --delete --files-from=.rsynclist -az ./ "$SSHTARGET:$BUILDDIR"
+
+set +x
+
+echo "--- Running $CIRCLE_JOB remotely"
+
+ssh $SSHTARGET <<_HERE
+    set +x -e
+    cd $BUILDDIR
+    # let's share the target dir with our last run on this branch/job-type
+    # cargo will make sure to block/unblock us properly 
+    export CARGO_TARGET_DIR=\`pwd\`/../target
+    export TARGET=release
+    export DCC_PY_LIVECONFIG=$DCC_PY_LIVECONFIG
+
+    #we rely on tox/virtualenv being available in the host
+    #rm -rf virtualenv venv
+    #virtualenv -q -p python3.7 venv 
+    #source venv/bin/activate
+    #pip install -q tox virtualenv
+
+    set -x
+    which python
+    source \$HOME/venv/bin/activate
+    which python
+
+    bash ci_scripts/run-python-test.sh 
+_HERE
--- a/ci_scripts/remote_tests_rust.sh
+++ b/ci_scripts/remote_tests_rust.sh
@@ -0,0 +1,32 @@
+#!/bin/bash 
+
+export BRANCH=${CIRCLE_BRANCH:?branch to build}
+export REPONAME=${CIRCLE_PROJECT_REPONAME:?repository name}
+export SSHTARGET=ci@b1.delta.chat
+
+# we construct the BUILDDIR such that we can easily share the
+# CARGO_TARGET_DIR between runs ("..")
+export BUILDDIR=ci_builds/$REPONAME/$BRANCH/${CIRCLE_JOB:?jobname}/${CIRCLE_BUILD_NUM:?circle-build-number}
+
+set -e
+
+echo "--- Copying files to $SSHTARGET:$BUILDDIR"
+
+ssh -oBatchMode=yes -oStrictHostKeyChecking=no  $SSHTARGET mkdir -p "$BUILDDIR"
+git ls-files >.rsynclist 
+rsync --delete --files-from=.rsynclist -az ./ "$SSHTARGET:$BUILDDIR"
+
+echo "--- Running $CIRCLE_JOB remotely"
+
+ssh $SSHTARGET <<_HERE
+    set +x -e
+    cd $BUILDDIR
+    # let's share the target dir with our last run on this branch/job-type
+    # cargo will make sure to block/unblock us properly 
+    export CARGO_TARGET_DIR=\`pwd\`/../target
+    export TARGET=x86_64-unknown-linux-gnu
+    export RUSTC_WRAPPER=sccache
+
+    bash ci_scripts/run-rust-test.sh
+_HERE
+
--- a/ci_scripts/run-python-test.sh
+++ b/ci_scripts/run-python-test.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+#
+# Run functional tests for Delta Chat core using the python bindings 
+# and tox/pytest. 
+
+set -e -x
+
+# for core-building and python install step
+export DCC_RS_TARGET=release
+export DCC_RS_DEV=`pwd`
+
+cd python
+
+python install_python_bindings.py onlybuild
+
+# remove and inhibit writing PYC files 
+rm -rf tests/__pycache__
+rm -rf src/deltachat/__pycache__
+export PYTHONDONTWRITEBYTECODE=1
+
+# run python tests (tox invokes pytest to run tests in python/tests)
+#TOX_PARALLEL_NO_SPINNER=1 tox -e lint,doc
+tox -e lint
+tox -e doc,py37
--- a/ci_scripts/run-rust-test.sh
+++ b/ci_scripts/run-rust-test.sh
@@ -2,7 +2,7 @@

 set -ex

-export RUST_TEST_THREADS=1
+#export RUST_TEST_THREADS=1
 export RUST_BACKTRACE=1
 export RUSTFLAGS='--deny warnings'
 export OPT="--target=$TARGET"
@@ -37,7 +37,9 @@ else
    export OPT_RELEASE_IGNORED="${OPT_RELEASE} -- --ignored"
 fi

-# Run all the test configurations:
+# Run all the test configurations 
+# RUSTC_WRAPPER=SCCACHE seems to destroy parallelism / prolong the test
+unset RUSTC_WRAPPER
 $CARGO_CMD $CARGO_SUBCMD $OPT
 $CARGO_CMD $CARGO_SUBCMD $OPT_RELEASE
 $CARGO_CMD $CARGO_SUBCMD $OPT_RELEASE_IGNORED
--- a/deltachat-ffi/Cargo.toml
+++ b/deltachat-ffi/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat_ffi"
-version = "1.0.0-beta.7"
+version = "1.0.0-beta.8"
 description = "Deltachat FFI"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"
--- a/deltachat-ffi/deltachat.h
+++ b/deltachat-ffi/deltachat.h
@@ -1096,9 +1096,9 @@ void            dc_set_draft                 (dc_context_t* context, uint32_t ch
 * Add a message to the device-chat.
 * Device-messages usually contain update information
 * and some hints that are added during the program runs, multi-device etc.
- *
- * Device-messages may be added from the core,
- * however, with this function, this can be done from the ui as well.
+ * The device-message may be defined by a label;
+ * if a message with the same label was added or skipped before,
+ * the message is not added again, even if the message was deleted in between.
 * If needed, the device-chat is created before.
 *
 * Sends the event #DC_EVENT_MSGS_CHANGED on success.
@@ -1106,33 +1106,50 @@ void            dc_set_draft                 (dc_context_t* context, uint32_t ch
 *
 * @memberof dc_context_t
 * @param context The context as created by dc_context_new().
- * @param msg Message to be added to the device-chat.
- *     The message appears to the user as an incoming message.
- * @return The ID of the added message.
- */
-uint32_t        dc_add_device_msg            (dc_context_t* context, dc_msg_t* msg);
-
-
-/**
- * Add a message only one time to the device-chat.
- * The device-message is defined by a name.
- * If a message with the same name was added before,
- * the message is not added again.
- * Use dc_add_device_msg() to add device-messages unconditionally.
- *
- * Sends the event #DC_EVENT_MSGS_CHANGED on success.
- *
- * @memberof dc_context_t
- * @param context The context as created by dc_context_new().
 * @param label A unique name for the message to add.
 *     The label is typically not displayed to the user and
 *     must be created from the characters `A-Z`, `a-z`, `0-9`, `_` or `-`.
+ *     If you pass NULL here, the message is added unconditionally.
 * @param msg Message to be added to the device-chat.
 *     The message appears to the user as an incoming message.
- * @return The ID of the added message,
- *     this might be the id of an older message with the same name.
+ *     If you pass NULL here, only the given label will be added
+ *     and block adding messages with that label in the future.
+ * @return The ID of the just added message,
+ *     if the message was already added or no message to add is given, 0 is returned.
+ *
+ * Example:
+ * ~~~
+ * dc_msg_t* welcome_msg = dc_msg_new(DC_MSG_TEXT);
+ * dc_msg_set_text(welcome_msg, "great that you give this app a try!");
+ *
+ * dc_msg_t* changelog_msg = dc_msg_new(DC_MSG_TEXT);
+ * dc_msg_set_text(changelog_msg, "we have added 3 new emojis :)");
+ *
+ * if (dc_add_device_msg(context, "welcome", welcome_msg)) {
+ *     // do not add the changelog on a new installations -
+ *     // not now and not when this code is executed again
+ *     dc_add_device_msg(context, "update-123", NULL);
+ * } else {
+ *     // welcome message was not added now, this is an oder installation,
+ *     // add a changelog
+ *     dc_add_device_msg(context, "update-123", changelog_msg);
+ * }
+ * ~~~
 */
-uint32_t        dc_add_device_msg_once       (dc_context_t* context, const char* label, dc_msg_t* msg);
+uint32_t        dc_add_device_msg            (dc_context_t* context, const char* label, dc_msg_t* msg);
+
+
+/**
+ * Check if a device-message with a given label was ever added.
+ * Device-messages can be added dc_add_device_msg().
+ *
+ * @memberof dc_context_t
+ * @param context The context as created by dc_context_new().
+ * @param label Label of the message to check.
+ * @return 1=A message with this label was added at some point,
+ *     0=A message with this label was never added.
+ */
+int             dc_was_device_msg_ever_added (dc_context_t* context, const char* label);


 /**
@@ -2760,9 +2777,7 @@ int             dc_chat_is_self_talk         (const dc_chat_t* chat);
 * From the ui view, device-talks are not very special,
 * the user can delete and forward messages, archive the chat, set notifications etc.
 *
- * Messages may be added from the core to the device chat,
- * so the chat just pops up as usual.
- * However, if needed the ui can also add messages using dc_add_device_msg()
+ * Messages can be added to the device-talk using dc_add_device_msg()
 *
 * @memberof dc_chat_t
 * @param chat The chat object.
--- a/deltachat-ffi/src/lib.rs
+++ b/deltachat-ffi/src/lib.rs
@@ -461,7 +461,7 @@ pub unsafe extern "C" fn dc_perform_imap_jobs(context: *mut dc_context_t) {
    }
    let ffi_context = &*context;
    ffi_context
-        .with_inner(|ctx| job::perform_imap_jobs(ctx))
+        .with_inner(|ctx| job::perform_inbox_jobs(ctx))
        .unwrap_or(())
 }

@@ -473,19 +473,20 @@ pub unsafe extern "C" fn dc_perform_imap_fetch(context: *mut dc_context_t) {
    }
    let ffi_context = &*context;
    ffi_context
-        .with_inner(|ctx| job::perform_imap_fetch(ctx))
+        .with_inner(|ctx| job::perform_inbox_fetch(ctx))
        .unwrap_or(())
 }

 #[no_mangle]
 pub unsafe extern "C" fn dc_perform_imap_idle(context: *mut dc_context_t) {
+    // TODO rename function in co-ordination with UIs
    if context.is_null() {
        eprintln!("ignoring careless call to dc_perform_imap_idle()");
        return;
    }
    let ffi_context = &*context;
    ffi_context
-        .with_inner(|ctx| job::perform_imap_idle(ctx))
+        .with_inner(|ctx| job::perform_inbox_idle(ctx))
        .unwrap_or(())
 }

@@ -497,7 +498,7 @@ pub unsafe extern "C" fn dc_interrupt_imap_idle(context: *mut dc_context_t) {
    }
    let ffi_context = &*context;
    ffi_context
-        .with_inner(|ctx| job::interrupt_imap_idle(ctx))
+        .with_inner(|ctx| job::interrupt_inbox_idle(ctx, true))
        .unwrap_or(())
 }

@@ -812,40 +813,50 @@ pub unsafe extern "C" fn dc_set_draft(
 }

 #[no_mangle]
-pub unsafe extern "C" fn dc_add_device_msg(context: *mut dc_context_t, msg: *mut dc_msg_t) -> u32 {
-    if context.is_null() || msg.is_null() {
+pub unsafe extern "C" fn dc_add_device_msg(
+    context: *mut dc_context_t,
+    label: *const libc::c_char,
+    msg: *mut dc_msg_t,
+) -> u32 {
+    if context.is_null() || (label.is_null() && msg.is_null()) {
        eprintln!("ignoring careless call to dc_add_device_msg()");
        return 0;
    }
    let ffi_context = &mut *context;
-    let ffi_msg = &mut *msg;
+    let msg = if msg.is_null() {
+        None
+    } else {
+        let ffi_msg: &mut MessageWrapper = &mut *msg;
+        Some(&mut ffi_msg.message)
+    };
    ffi_context
        .with_inner(|ctx| {
-            chat::add_device_msg(ctx, &mut ffi_msg.message)
-                .unwrap_or_log_default(ctx, "Failed to add device message")
+            chat::add_device_msg(
+                ctx,
+                to_opt_string_lossy(label).as_ref().map(|x| x.as_str()),
+                msg,
+            )
+            .unwrap_or_log_default(ctx, "Failed to add device message")
        })
        .map(|msg_id| msg_id.to_u32())
        .unwrap_or(0)
 }

 #[no_mangle]
-pub unsafe extern "C" fn dc_add_device_msg_once(
+pub unsafe extern "C" fn dc_was_device_msg_ever_added(
    context: *mut dc_context_t,
    label: *const libc::c_char,
-    msg: *mut dc_msg_t,
-) -> u32 {
-    if context.is_null() || label.is_null() || msg.is_null() {
-        eprintln!("ignoring careless call to dc_add_device_msg_once()");
+) -> libc::c_int {
+    if context.is_null() || label.is_null() {
+        eprintln!("ignoring careless call to dc_was_device_msg_ever_added()");
        return 0;
    }
    let ffi_context = &mut *context;
-    let ffi_msg = &mut *msg;
    ffi_context
        .with_inner(|ctx| {
-            chat::add_device_msg_once(ctx, &to_string_lossy(label), &mut ffi_msg.message)
-                .unwrap_or_log_default(ctx, "Failed to add device message once")
+            chat::was_device_msg_ever_added(ctx, &to_string_lossy(label)).unwrap_or(false)
+                as libc::c_int
        })
-        .map(|msg_id| msg_id.to_u32())
        .unwrap_or(0)
 }

--- a/examples/repl/cmdline.rs
+++ b/examples/repl/cmdline.rs
@@ -496,7 +496,7 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
            println!("{:#?}", context.get_info());
        }
        "interrupt" => {
-            interrupt_imap_idle(context);
+            interrupt_inbox_idle(context, true);
        }
        "maybenetwork" => {
            maybe_network(context);
@@ -837,7 +837,7 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
            );
            let mut msg = Message::new(Viewtype::Text);
            msg.set_text(Some(arg1.to_string()));
-            chat::add_device_msg(context, &mut msg)?;
+            chat::add_device_msg(context, None, Some(&mut msg))?;
        }
        "listmedia" => {
            ensure!(sel_chat.is_some(), "No chat selected.");
--- a/examples/repl/main.rs
+++ b/examples/repl/main.rs
@@ -150,11 +150,11 @@ fn start_threads(c: Arc<RwLock<Context>>) {
    let ctx = c.clone();
    let handle_imap = std::thread::spawn(move || loop {
        while_running!({
-            perform_imap_jobs(&ctx.read().unwrap());
-            perform_imap_fetch(&ctx.read().unwrap());
+            perform_inbox_jobs(&ctx.read().unwrap());
+            perform_inbox_fetch(&ctx.read().unwrap());
            while_running!({
                let context = ctx.read().unwrap();
-                perform_imap_idle(&context);
+                perform_inbox_idle(&context);
            });
        });
    });
@@ -202,7 +202,7 @@ fn stop_threads(context: &Context) {
        println!("Stopping threads");
        IS_RUNNING.store(false, Ordering::Relaxed);

-        interrupt_imap_idle(context);
+        interrupt_inbox_idle(context, true);
        interrupt_mvbox_idle(context);
        interrupt_sentbox_idle(context);
        interrupt_smtp_idle(context);
@@ -455,9 +455,9 @@ unsafe fn handle_cmd(line: &str, ctx: Arc<RwLock<Context>>) -> Result<ExitResult
        }
        "imap-jobs" => {
            if HANDLE.clone().lock().unwrap().is_some() {
-                println!("imap-jobs are already running in a thread.");
+                println!("inbox-jobs are already running in a thread.");
            } else {
-                perform_imap_jobs(&ctx.read().unwrap());
+                perform_inbox_jobs(&ctx.read().unwrap());
            }
        }
        "configure" => {
--- a/examples/simple.rs
+++ b/examples/simple.rs
@@ -11,7 +11,8 @@ use deltachat::configure::*;
 use deltachat::contact::*;
 use deltachat::context::*;
 use deltachat::job::{
-    perform_imap_fetch, perform_imap_idle, perform_imap_jobs, perform_smtp_idle, perform_smtp_jobs,
+    perform_inbox_fetch, perform_inbox_idle, perform_inbox_jobs, perform_smtp_idle,
+    perform_smtp_jobs,
 };
 use deltachat::Event;

@@ -50,12 +51,12 @@ fn main() {
    let r1 = running.clone();
    let t1 = thread::spawn(move || {
        while *r1.read().unwrap() {
-            perform_imap_jobs(&ctx1);
+            perform_inbox_jobs(&ctx1);
            if *r1.read().unwrap() {
-                perform_imap_fetch(&ctx1);
+                perform_inbox_fetch(&ctx1);

                if *r1.read().unwrap() {
-                    perform_imap_idle(&ctx1);
+                    perform_inbox_idle(&ctx1);
                }
            }
        }
@@ -113,7 +114,7 @@ fn main() {
    println!("stopping threads");

    *running.clone().write().unwrap() = false;
-    deltachat::job::interrupt_imap_idle(&ctx);
+    deltachat::job::interrupt_inbox_idle(&ctx, true);
    deltachat::job::interrupt_smtp_idle(&ctx);

    println!("joining");
--- a/mmime/Cargo.toml
+++ b/mmime/Cargo.toml
@@ -20,4 +20,4 @@ memmap = "0.7.0"
 lazy_static = "1.3.0"
 rand = "0.6.5"
 chrono = "0.4.6"
-hex = "0.3.2"
+hex = "0.4.0"
--- a/python/install_python_bindings.py
+++ b/python/install_python_bindings.py
@@ -9,17 +9,23 @@ import subprocess
 import sys

 if __name__ == "__main__":
-    os.environ["DCC_RS_TARGET"] = target = "release"
+    target = os.environ.get("DCC_RS_TARGET")
+    if target is None:
+        os.environ["DCC_RS_TARGET"] = target = "release"
    if "DCC_RS_DEV" not in os.environ:
        dn = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
        os.environ["DCC_RS_DEV"] = dn

+    # build the core library  in release + debug mode because
+    # as of Nov 2019 rPGP generates RSA keys which take
+    # prohibitively long for non-release installs
    os.environ["RUSTFLAGS"] = "-g"
    subprocess.check_call([
        "cargo", "build", "-p", "deltachat_ffi", "--" + target
    ])
    subprocess.check_call("rm -rf build/ src/deltachat/*.so" , shell=True)

-    subprocess.check_call([
-        sys.executable, "-m", "pip", "install", "-e", "."
-    ])
+    if len(sys.argv) <= 1 or sys.argv[1] != "onlybuild":
+        subprocess.check_call([
+            sys.executable, "-m", "pip", "install", "-e", "."
+        ])
--- a/python/src/deltachat/_build.py
+++ b/python/src/deltachat/_build.py
@@ -29,7 +29,10 @@ def ffibuilder():
            extra_link_args = []
        else:
            raise NotImplementedError("Compilation not supported yet on Windows, can you help?")
-        objs = [os.path.join(projdir, 'target', target, 'libdeltachat.a')]
+        target_dir = os.environ.get("CARGO_TARGET_DIR")
+        if target_dir is None:
+            target_dir = os.path.join(projdir, 'target')
+        objs = [os.path.join(target_dir, target, 'libdeltachat.a')]
        assert os.path.exists(objs[0]), objs
        incs = [os.path.join(projdir, 'deltachat-ffi')]
    else:
--- a/python/src/deltachat/account.py
+++ b/python/src/deltachat/account.py
@@ -573,8 +573,10 @@ class IOThreads:
        self._log_event("py-bindings-info", 0, "INBOX THREAD START")
        while not self._thread_quitflag:
            lib.dc_perform_imap_jobs(self._dc_context)
-            lib.dc_perform_imap_fetch(self._dc_context)
-            lib.dc_perform_imap_idle(self._dc_context)
+            if not self._thread_quitflag:
+                lib.dc_perform_imap_fetch(self._dc_context)
+            if not self._thread_quitflag:
+                lib.dc_perform_imap_idle(self._dc_context)
        self._log_event("py-bindings-info", 0, "INBOX THREAD FINISHED")

    def mvbox_thread_run(self):
--- a/python/tests/test_account.py
+++ b/python/tests/test_account.py
@@ -430,15 +430,25 @@ class TestOnlineAccount:
        assert self_addr not in ev[2]
        ev = ac1._evlogger.get_matching("DC_EVENT_DELETED_BLOB_FILE")

-    def test_mvbox_sentbox_threads(self, acfactory):
+    def test_mvbox_sentbox_threads(self, acfactory, lp):
+        lp.sec("ac1: start with mvbox thread")
        ac1 = acfactory.get_online_configuring_account(mvbox=True, sentbox=True)
+
+        lp.sec("ac2: start without mvbox/sentbox threads")
        ac2 = acfactory.get_online_configuring_account()
+
+        lp.sec("ac2: waiting for configuration")
        wait_configuration_progress(ac2, 1000)
+
+        lp.sec("ac1: waiting for configuration")
        wait_configuration_progress(ac1, 1000)
+
+        lp.sec("ac1: send message and wait for ac2 to receive it")
        chat = self.get_chat(ac1, ac2)
        chat.send_text("message1")
        ev = ac2._evlogger.get_matching("DC_EVENT_INCOMING_MSG|DC_EVENT_MSGS_CHANGED")
        assert ev[2] > const.DC_CHAT_ID_LAST_SPECIAL
+        lp.sec("test finished")

    def test_move_works(self, acfactory):
        ac1 = acfactory.get_online_configuring_account()
@@ -678,7 +688,6 @@ class TestOnlineAccount:
        assert len(messages) == 1
        assert messages[0].text == "msg1"

-        pytest.xfail("cannot export twice yet, probably due to interrupt_idle failing")
        # wait until a second passed since last backup
        # because get_latest_backupfile() shall return the latest backup
        # from a UI it's unlikely anyone manages to export two
@@ -721,6 +730,7 @@ class TestOnlineAccount:
        ac2._evlogger.set_timeout(30)
        wait_configuration_progress(ac2, 1000)
        wait_configuration_progress(ac1, 1000)
+
        lp.sec("trigger ac setup message but ignore")
        assert ac1.get_info()["fingerprint"] != ac2.get_info()["fingerprint"]
        ac1.initiate_key_transfer()
@@ -732,6 +742,7 @@ class TestOnlineAccount:
        msg = ac2.get_message_by_id(ev[2])
        assert msg.is_setup_message()
        assert msg.get_setupcodebegin() == setup_code2[:2]
+
        lp.sec("process second setup message")
        msg.continue_key_transfer(setup_code2)
        assert ac1.get_info()["fingerprint"] == ac2.get_info()["fingerprint"]
@@ -899,7 +910,7 @@ class TestOnlineConfigureFails:
        ac1.start_threads()
        wait_configuration_progress(ac1, 500)
        ev1 = ac1._evlogger.get_matching("DC_EVENT_ERROR_NETWORK")
-        assert "authentication failed" in ev1[2].lower()
+        assert "cannot login" in ev1[2].lower()
        wait_configuration_progress(ac1, 0, 0)

    def test_invalid_user(self, acfactory):
@@ -908,7 +919,7 @@ class TestOnlineConfigureFails:
        ac1.start_threads()
        wait_configuration_progress(ac1, 500)
        ev1 = ac1._evlogger.get_matching("DC_EVENT_ERROR_NETWORK")
-        assert "authentication failed" in ev1[2].lower()
+        assert "cannot login" in ev1[2].lower()
        wait_configuration_progress(ac1, 0, 0)

    def test_invalid_domain(self, acfactory):
--- a/python/tests/test_lowlevel.py
+++ b/python/tests/test_lowlevel.py
@@ -41,7 +41,7 @@ def test_dc_close_events(tmpdir):
            else:
                print("skipping event", *ev)

-    find("disconnecting INBOX-watch")
+    find("disconnecting inbox-thread")
    find("disconnecting sentbox-thread")
    find("disconnecting mvbox-thread")
    find("disconnecting SMTP")
--- a/python/tox.ini
+++ b/python/tox.ini
@@ -1,19 +1,25 @@
 [tox]
 # make sure to update environment list in travis.yml and appveyor.yml
 envlist =
-    py35
+    py37
    lint
    auditwheels

 [testenv]
 commands = 
-    pytest -v -rsXx {posargs:tests}
-    python tests/package_wheels.py {toxworkdir}/wheelhouse
+    # (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} 
+    # python tests/package_wheels.py {toxworkdir}/wheelhouse
 passenv = 
    TRAVIS 
    DCC_RS_DEV
    DCC_RS_TARGET
    DCC_PY_LIVECONFIG
+    CARGO_TARGET_DIR
+    RUSTC_WRAPPER
 deps = 
    pytest
    pytest-rerunfailures
@@ -28,7 +34,6 @@ deps = auditwheel
 commands = 
    python tests/auditwheels.py {toxworkdir}/wheelhouse

-
 [testenv:lint]
 skipsdist = True
 usedevelop = True
@@ -43,18 +48,28 @@ commands =
    rst-lint --encoding 'utf-8' README.rst

 [testenv:doc]
-basepython = python3.5
+changedir=doc
 deps =
    sphinx==2.2.0
    breathe
-
-changedir = doc
 commands =
-    sphinx-build -w docker-toxdoc-warnings.log -b html . _build/html
+    sphinx-build -w toxdoc-warnings.log -b html . _build/html
+
+
+[testenv:lintdoc]
+skipsdist = True
+usedevelop = True
+deps =
+    {[testenv:lint]deps}
+    {[testenv:doc]deps}
+commands =
+    {[testenv:lint]commands}
+    {[testenv:doc]commands}
+


 [pytest]
-addopts = -v -rs --reruns 3 --reruns-delay 2
+addopts = -v -rs 
 python_files = tests/test_*.py 
 norecursedirs = .tox 
 xfail_strict=true
--- a/2
+++ b/2
@@ -1 +1 @@
-nightly-2019-08-13
+nightly-2019-11-06
--- a/src/blob.rs
+++ b/src/blob.rs
@@ -140,9 +140,10 @@ impl<'a> BlobObject<'a> {
        context: &Context,
        src: impl AsRef<Path>,
    ) -> std::result::Result<BlobObject, BlobError> {
-        match src.as_ref().starts_with(context.get_blobdir()) {
-            true => BlobObject::from_path(context, src),
-            false => BlobObject::create_and_copy(context, src),
+        if src.as_ref().starts_with(context.get_blobdir()) {
+            BlobObject::from_path(context, src)
+        } else {
+            BlobObject::create_and_copy(context, src)
        }
    }

@@ -264,13 +265,13 @@ impl<'a> BlobObject<'a> {
    fn sanitise_name(name: &str) -> (String, String) {
        let mut name = name.to_string();
        for part in name.rsplit('/') {
-            if part.len() > 0 {
+            if !part.is_empty() {
                name = part.to_string();
                break;
            }
        }
        for part in name.rsplit('\\') {
-            if part.len() > 0 {
+            if !part.is_empty() {
                name = part.to_string();
                break;
            }
@@ -282,13 +283,13 @@ impl<'a> BlobObject<'a> {
        };

        let clean = sanitize_filename::sanitize_with_options(name, opts);
-        let mut iter = clean.rsplitn(2, '.');
-        let mut ext = iter.next().unwrap_or_default().to_string();
+        let mut iter = clean.splitn(2, '.');
        let mut stem = iter.next().unwrap_or_default().to_string();
-        ext.truncate(32);
+        let mut ext = iter.next().unwrap_or_default().to_string();
        stem.truncate(64);
-        match stem.len() {
-            0 => (ext, "".to_string()),
+        ext.truncate(32);
+        match ext.len() {
+            0 => (stem, "".to_string()),
            _ => (stem, format!(".{}", ext).to_lowercase()),
        }
    }
@@ -609,6 +610,26 @@ mod tests {
        }
    }

+    #[test]
+    fn test_double_ext_preserved() {
+        let t = dummy_context();
+        BlobObject::create(&t.ctx, "foo.tar.gz", b"hello").unwrap();
+        let foo = t.ctx.get_blobdir().join("foo.tar.gz");
+        assert!(foo.exists());
+        BlobObject::create(&t.ctx, "foo.tar.gz", b"world").unwrap();
+        for dirent in fs::read_dir(t.ctx.get_blobdir()).unwrap() {
+            let fname = dirent.unwrap().file_name();
+            if fname == foo.file_name().unwrap() {
+                assert_eq!(fs::read(&foo).unwrap(), b"hello");
+            } else {
+                let name = fname.to_str().unwrap();
+                println!("{}", name);
+                assert!(name.starts_with("foo"));
+                assert!(name.ends_with(".tar.gz"));
+            }
+        }
+    }
+
    #[test]
    fn test_create_long_names() {
        let t = dummy_context();
--- a/src/chat.rs
+++ b/src/chat.rs
@@ -100,7 +100,7 @@ impl Chat {
                        }

                        if chat.param.exists(Param::Selftalk) {
-                            chat.name = context.stock_str(StockMessage::SelfMsg).into();
+                            chat.name = context.stock_str(StockMessage::SavedMessages).into();
                        } else if chat.param.exists(Param::Devicetalk) {
                            chat.name = context.stock_str(StockMessage::DeviceMessages).into();
                        }
@@ -603,6 +603,20 @@ fn copy_device_icon_to_blobs(context: &Context) -> Result<String, Error> {
    Ok(blob.as_name().to_string())
 }

+pub fn update_saved_messages_icon(context: &Context) -> Result<(), Error> {
+    // if there is no saved-messages chat, there is nothing to update. this is no error.
+    if let Ok((chat_id, _)) = lookup_by_contact_id(context, DC_CONTACT_ID_SELF) {
+        let icon = include_bytes!("../assets/icon-saved-messages.png");
+        let blob = BlobObject::create(context, "icon-saved-messages.png".to_string(), icon)?;
+        let icon = blob.as_name().to_string();
+
+        let mut chat = Chat::load_from_db(context, chat_id)?;
+        chat.param.set(Param::ProfileImage, icon);
+        chat.update_param(context)?;
+    }
+    Ok(())
+}
+
 pub fn create_or_lookup_by_contact_id(
    context: &Context,
    contact_id: u32,
@@ -652,6 +666,10 @@ pub fn create_or_lookup_by_contact_id(
        params![],
    )?;

+    if contact_id == DC_CONTACT_ID_SELF {
+        update_saved_messages_icon(context)?;
+    }
+
    Ok((chat_id, create_blocked))
 }

@@ -1189,9 +1207,8 @@ pub fn get_chat_media(
            |ids| {
                let mut ret = Vec::new();
                for id in ids {
-                    match id {
-                        Ok(msg_id) => ret.push(msg_id),
-                        Err(_) => (),
+                    if let Ok(msg_id) = id {
+                        ret.push(msg_id)
                    }
                }
                Ok(ret)
@@ -1512,7 +1529,7 @@ pub(crate) fn add_contact_to_chat_ex(
        msg.id = send_msg(context, chat_id, &mut msg)?;
        context.call_cb(Event::MsgsChanged {
            chat_id,
-            msg_id: MsgId::from(msg.id),
+            msg_id: msg.id,
        });
    }
    context.call_cb(Event::MsgsChanged {
@@ -1934,78 +1951,78 @@ pub fn get_chat_id_by_grpid(context: &Context, grpid: impl AsRef<str>) -> (u32,
        .unwrap_or((0, false, Blocked::Not))
 }

-pub fn add_device_msg(context: &Context, msg: &mut Message) -> Result<MsgId, Error> {
-    add_device_msg_maybe_labelled(context, None, msg)
-}
-
-pub fn add_device_msg_once(
-    context: &Context,
-    label: &str,
-    msg: &mut Message,
-) -> Result<MsgId, Error> {
-    add_device_msg_maybe_labelled(context, Some(label), msg)
-}
-
-fn add_device_msg_maybe_labelled(
+pub fn add_device_msg(
    context: &Context,
    label: Option<&str>,
-    msg: &mut Message,
+    msg: Option<&mut Message>,
 ) -> Result<MsgId, Error> {
+    ensure!(
+        label.is_some() || msg.is_some(),
+        "device-messages need label, msg or both"
+    );
    let (chat_id, _blocked) =
        create_or_lookup_by_contact_id(context, DC_CONTACT_ID_DEVICE, Blocked::Not)?;
-    let rfc724_mid = dc_create_outgoing_rfc724_mid(None, "@device");
+    let mut msg_id = MsgId::new_unset();

-    // chat_id has an sql-index so it makes sense to add this although redundant
    if let Some(label) = label {
-        if let Ok(msg_id) = context.sql.query_row(
-            "SELECT id FROM msgs WHERE chat_id=? AND label=?",
-            params![chat_id, label],
-            |row| {
-                let msg_id: MsgId = row.get(0)?;
-                Ok(msg_id)
-            },
-        ) {
-            info!(
-                context,
-                "device-message {} already exist as {}", label, msg_id
-            );
+        if was_device_msg_ever_added(context, label)? {
+            info!(context, "device-message {} already added", label);
            return Ok(msg_id);
        }
    }

-    prepare_msg_blob(context, msg)?;
-    unarchive(context, chat_id)?;
+    if let Some(msg) = msg {
+        let rfc724_mid = dc_create_outgoing_rfc724_mid(None, "@device");
+        prepare_msg_blob(context, msg)?;
+        unarchive(context, chat_id)?;

-    context.sql.execute(
-        "INSERT INTO msgs (chat_id,from_id,to_id, timestamp,type,state, txt,param,rfc724_mid,label) \
-         VALUES (?,?,?, ?,?,?, ?,?,?,?);",
-        params![
-            chat_id,
-            DC_CONTACT_ID_DEVICE,
-            DC_CONTACT_ID_SELF,
-            dc_create_smeared_timestamp(context),
-            msg.type_0,
-            MessageState::InFresh,
-            msg.text.as_ref().map_or("", String::as_str),
-            msg.param.to_string(),
-            rfc724_mid,
-            label.unwrap_or_default(),
-        ],
-    )?;
+        context.sql.execute(
+            "INSERT INTO msgs (chat_id,from_id,to_id, timestamp,type,state, txt,param,rfc724_mid) \
+             VALUES (?,?,?, ?,?,?, ?,?,?);",
+            params![
+                chat_id,
+                DC_CONTACT_ID_DEVICE,
+                DC_CONTACT_ID_SELF,
+                dc_create_smeared_timestamp(context),
+                msg.type_0,
+                MessageState::InFresh,
+                msg.text.as_ref().map_or("", String::as_str),
+                msg.param.to_string(),
+                rfc724_mid,
+            ],
+        )?;

-    let row_id = sql::get_rowid(context, &context.sql, "msgs", "rfc724_mid", &rfc724_mid);
-    let msg_id = MsgId::new(row_id);
-    context.call_cb(Event::IncomingMsg { chat_id, msg_id });
-    info!(
-        context,
-        "device-message {} added as {}",
-        label.unwrap_or("without label"),
-        msg_id
-    );
+        let row_id = sql::get_rowid(context, &context.sql, "msgs", "rfc724_mid", &rfc724_mid);
+        msg_id = MsgId::new(row_id);
+    }
+
+    if let Some(label) = label {
+        context.sql.execute(
+            "INSERT INTO devmsglabels (label) VALUES (?);",
+            params![label],
+        )?;
+    }
+
+    if !msg_id.is_unset() {
+        context.call_cb(Event::IncomingMsg { chat_id, msg_id });
+    }

    Ok(msg_id)
 }

+pub fn was_device_msg_ever_added(context: &Context, label: &str) -> Result<bool, Error> {
+    ensure!(!label.is_empty(), "empty label");
+    if let Ok(()) = context.sql.query_row(
+        "SELECT label FROM devmsglabels WHERE label=?",
+        params![label],
+        |_| Ok(()),
+    ) {
+        return Ok(true);
+    }
+
+    Ok(false)
+}
+
 pub fn add_info_msg(context: &Context, chat_id: u32, text: impl AsRef<str>) {
    let rfc724_mid = dc_create_outgoing_rfc724_mid(None, "@device");

@@ -2096,7 +2113,8 @@ mod tests {
        assert!(!chat.archived);
        assert!(!chat.is_device_talk());
        assert!(chat.can_send());
-        assert_eq!(chat.name, t.ctx.stock_str(StockMessage::SelfMsg));
+        assert_eq!(chat.name, t.ctx.stock_str(StockMessage::SavedMessages));
+        assert!(chat.get_profile_image(&t.ctx).is_some());
    }

    #[test]
@@ -2113,18 +2131,18 @@ mod tests {
    }

    #[test]
-    fn test_add_device_msg() {
+    fn test_add_device_msg_unlabelled() {
        let t = test_context(Some(Box::new(logging_cb)));

        // add two device-messages
        let mut msg1 = Message::new(Viewtype::Text);
        msg1.text = Some("first message".to_string());
-        let msg1_id = add_device_msg(&t.ctx, &mut msg1);
+        let msg1_id = add_device_msg(&t.ctx, None, Some(&mut msg1));
        assert!(msg1_id.is_ok());

        let mut msg2 = Message::new(Viewtype::Text);
        msg2.text = Some("second message".to_string());
-        let msg2_id = add_device_msg(&t.ctx, &mut msg2);
+        let msg2_id = add_device_msg(&t.ctx, None, Some(&mut msg2));
        assert!(msg2_id.is_ok());
        assert_ne!(msg1_id.as_ref().unwrap(), msg2_id.as_ref().unwrap());

@@ -2148,34 +2166,35 @@ mod tests {
    }

    #[test]
-    fn test_add_device_msg_once() {
+    fn test_add_device_msg_labelled() {
        let t = test_context(Some(Box::new(logging_cb)));

        // add two device-messages with the same label (second attempt is not added)
        let mut msg1 = Message::new(Viewtype::Text);
        msg1.text = Some("first message".to_string());
-        let msg1_id = add_device_msg_once(&t.ctx, "any-label", &mut msg1);
+        let msg1_id = add_device_msg(&t.ctx, Some("any-label"), Some(&mut msg1));
        assert!(msg1_id.is_ok());
+        assert!(!msg1_id.as_ref().unwrap().is_unset());

        let mut msg2 = Message::new(Viewtype::Text);
        msg2.text = Some("second message".to_string());
-        let msg2_id = add_device_msg_once(&t.ctx, "any-label", &mut msg2);
+        let msg2_id = add_device_msg(&t.ctx, Some("any-label"), Some(&mut msg2));
        assert!(msg2_id.is_ok());
-        assert_eq!(msg1_id.as_ref().unwrap(), msg2_id.as_ref().unwrap());
+        assert!(msg2_id.as_ref().unwrap().is_unset());

        // check added message
-        let msg2 = message::Message::load_from_db(&t.ctx, msg2_id.unwrap());
-        assert!(msg2.is_ok());
-        let msg2 = msg2.unwrap();
-        assert_eq!(msg1_id.unwrap(), msg2.id);
-        assert_eq!(msg2.text.as_ref().unwrap(), "first message");
-        assert_eq!(msg2.from_id, DC_CONTACT_ID_DEVICE);
-        assert_eq!(msg2.to_id, DC_CONTACT_ID_SELF);
-        assert!(!msg2.is_info());
-        assert!(!msg2.is_setupmessage());
+        let msg1 = message::Message::load_from_db(&t.ctx, *msg1_id.as_ref().unwrap());
+        assert!(msg1.is_ok());
+        let msg1 = msg1.unwrap();
+        assert_eq!(msg1_id.as_ref().unwrap(), &msg1.id);
+        assert_eq!(msg1.text.as_ref().unwrap(), "first message");
+        assert_eq!(msg1.from_id, DC_CONTACT_ID_DEVICE);
+        assert_eq!(msg1.to_id, DC_CONTACT_ID_SELF);
+        assert!(!msg1.is_info());
+        assert!(!msg1.is_setupmessage());

        // check device chat
-        let chat_id = msg2.chat_id;
+        let chat_id = msg1.chat_id;
        assert_eq!(get_msg_cnt(&t.ctx, chat_id), 1);
        assert!(chat_id > DC_CHAT_ID_LAST_SPECIAL);
        let chat = Chat::load_from_db(&t.ctx, chat_id);
@@ -2186,6 +2205,50 @@ mod tests {
        assert!(!chat.can_send());
        assert_eq!(chat.name, t.ctx.stock_str(StockMessage::DeviceMessages));
        assert!(chat.get_profile_image(&t.ctx).is_some());
+
+        // delete device message, make sure it is not added again
+        message::delete_msgs(&t.ctx, &[*msg1_id.as_ref().unwrap()]);
+        let msg1 = message::Message::load_from_db(&t.ctx, *msg1_id.as_ref().unwrap());
+        assert!(msg1.is_err() || msg1.unwrap().chat_id == DC_CHAT_ID_TRASH);
+        let msg3_id = add_device_msg(&t.ctx, Some("any-label"), Some(&mut msg2));
+        assert!(msg3_id.is_ok());
+        assert!(msg2_id.as_ref().unwrap().is_unset());
+    }
+
+    #[test]
+    fn test_add_device_msg_label_only() {
+        let t = test_context(Some(Box::new(logging_cb)));
+        let res = add_device_msg(&t.ctx, Some(""), None);
+        assert!(res.is_err());
+        let res = add_device_msg(&t.ctx, Some("some-label"), None);
+        assert!(res.is_ok());
+
+        let mut msg = Message::new(Viewtype::Text);
+        msg.text = Some("message text".to_string());
+
+        let msg_id = add_device_msg(&t.ctx, Some("some-label"), Some(&mut msg));
+        assert!(msg_id.is_ok());
+        assert!(msg_id.as_ref().unwrap().is_unset());
+
+        let msg_id = add_device_msg(&t.ctx, Some("unused-label"), Some(&mut msg));
+        assert!(msg_id.is_ok());
+        assert!(!msg_id.as_ref().unwrap().is_unset());
+    }
+
+    #[test]
+    fn test_was_device_msg_ever_added() {
+        let t = test_context(Some(Box::new(logging_cb)));
+        add_device_msg(&t.ctx, Some("some-label"), None).ok();
+        assert!(was_device_msg_ever_added(&t.ctx, "some-label").unwrap());
+
+        let mut msg = Message::new(Viewtype::Text);
+        msg.text = Some("message text".to_string());
+        add_device_msg(&t.ctx, Some("another-label"), Some(&mut msg)).ok();
+        assert!(was_device_msg_ever_added(&t.ctx, "another-label").unwrap());
+
+        assert!(!was_device_msg_ever_added(&t.ctx, "unused-label").unwrap());
+
+        assert!(was_device_msg_ever_added(&t.ctx, "").is_err());
    }

    fn chatlist_len(ctx: &Context, listflags: usize) -> usize {
@@ -2200,7 +2263,7 @@ mod tests {
        let t = dummy_context();
        let mut msg = Message::new(Viewtype::Text);
        msg.text = Some("foo".to_string());
-        let msg_id = add_device_msg(&t.ctx, &mut msg).unwrap();
+        let msg_id = add_device_msg(&t.ctx, None, Some(&mut msg)).unwrap();
        let chat_id1 = message::Message::load_from_db(&t.ctx, msg_id)
            .unwrap()
            .chat_id;
--- a/src/config.rs
+++ b/src/config.rs
@@ -3,6 +3,7 @@
 use strum::{EnumProperty, IntoEnumIterator};
 use strum_macros::{AsRefStr, Display, EnumIter, EnumProperty, EnumString};

+use crate::blob::BlobObject;
 use crate::constants::DC_VERSION_STR;
 use crate::context::Context;
 use crate::dc_tools::*;
@@ -115,13 +116,12 @@ impl Context {
    pub fn set_config(&self, key: Config, value: Option<&str>) -> Result<(), Error> {
        match key {
            Config::Selfavatar if value.is_some() => {
-                let rel_path = std::fs::canonicalize(value.unwrap())?;
-                self.sql
-                    .set_raw_config(self, key, Some(&rel_path.to_string_lossy()))
+                let blob = BlobObject::create_from_path(&self, value.unwrap())?;
+                self.sql.set_raw_config(self, key, Some(blob.as_name()))
            }
            Config::InboxWatch => {
                let ret = self.sql.set_raw_config(self, key, value);
-                interrupt_imap_idle(self);
+                interrupt_inbox_idle(self, true);
                ret
            }
            Config::SentboxWatch => {
@@ -167,6 +167,8 @@ mod tests {
    use std::str::FromStr;
    use std::string::ToString;

+    use crate::test_utils::*;
+
    #[test]
    fn test_to_string() {
        assert_eq!(Config::MailServer.to_string(), "mail_server");
@@ -183,4 +185,32 @@ mod tests {
    fn test_default_prop() {
        assert_eq!(Config::ImapFolder.get_str("default"), Some("INBOX"));
    }
+
+    #[test]
+    fn test_selfavatar() -> failure::Fallible<()> {
+        let t = dummy_context();
+        let avatar_src = t.dir.path().join("avatar.jpg");
+        std::fs::write(&avatar_src, b"avatar")?;
+        let avatar_blob = t.ctx.get_blobdir().join("avatar.jpg");
+        assert!(!avatar_blob.exists());
+        t.ctx
+            .set_config(Config::Selfavatar, Some(&avatar_src.to_str().unwrap()))?;
+        assert!(avatar_blob.exists());
+        assert_eq!(std::fs::read(&avatar_blob)?, b"avatar");
+        let avatar_cfg = t.ctx.get_config(Config::Selfavatar);
+        assert_eq!(avatar_cfg, avatar_blob.to_str().map(|s| s.to_string()));
+        Ok(())
+    }
+
+    #[test]
+    fn test_selfavatar_in_blobdir() -> failure::Fallible<()> {
+        let t = dummy_context();
+        let avatar_src = t.ctx.get_blobdir().join("avatar.jpg");
+        std::fs::write(&avatar_src, b"avatar")?;
+        t.ctx
+            .set_config(Config::Selfavatar, Some(&avatar_src.to_str().unwrap()))?;
+        let avatar_cfg = t.ctx.get_config(Config::Selfavatar);
+        assert_eq!(avatar_cfg, avatar_src.to_str().map(|s| s.to_string()));
+        Ok(())
+    }
 }
--- a/src/configure/mod.rs
+++ b/src/configure/mod.rs
@@ -7,7 +7,6 @@ use crate::constants::*;
 use crate::context::Context;
 use crate::dc_tools::*;
 use crate::e2ee;
-use crate::imap::*;
 use crate::job::*;
 use crate::login_param::LoginParam;
 use crate::oauth2::*;
@@ -64,15 +63,8 @@ pub fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {

    let mut param_autoconfig: Option<LoginParam> = None;

-    context.inbox.read().unwrap().disconnect(context);
    context
-        .sentbox_thread
-        .read()
-        .unwrap()
-        .imap
-        .disconnect(context);
-    context
-        .mvbox_thread
+        .inbox_thread
        .read()
        .unwrap()
        .imap
@@ -92,7 +84,7 @@ pub fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
    const STEP_3_INDEX: u8 = 13;
    let mut step_counter: u8 = 0;
    while !context.shall_stop_ongoing() {
-        step_counter = step_counter + 1;
+        step_counter += 1;

        let success = match step_counter {
            // Read login parameters from the database
@@ -358,9 +350,10 @@ pub fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
                    0
                };
                context
-                    .inbox
+                    .inbox_thread
                    .read()
                    .unwrap()
+                    .imap
                    .configure_folders(context, flags);
                true
            }
@@ -400,7 +393,12 @@ pub fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
        }
    }
    if imap_connected_here {
-        context.inbox.read().unwrap().disconnect(context);
+        context
+            .inbox_thread
+            .read()
+            .unwrap()
+            .imap
+            .disconnect(context);
    }
    if smtp_connected_here {
        context.smtp.clone().lock().unwrap().disconnect();
@@ -496,7 +494,13 @@ fn try_imap_one_param(context: &Context, param: &LoginParam) -> Option<bool> {
        param.mail_user, param.mail_server, param.mail_port, param.server_flags
    );
    info!(context, "Trying: {}", inf);
-    if context.inbox.read().unwrap().connect(context, &param) {
+    if context
+        .inbox_thread
+        .read()
+        .unwrap()
+        .imap
+        .connect(context, &param)
+    {
        info!(context, "success: {}", inf);
        return Some(true);
    }
@@ -565,26 +569,6 @@ fn try_smtp_one_param(context: &Context, param: &LoginParam) -> Option<bool> {
    }
 }

-/// Connects to the configured account
-pub fn dc_connect_to_configured_imap(context: &Context, imap: &Imap) -> libc::c_int {
-    let mut ret_connected = 0;
-
-    if imap.is_connected() {
-        ret_connected = 1
-    } else if !context.sql.get_raw_config_bool(context, "configured") {
-        warn!(context, "Not configured, cannot connect.",);
-    } else {
-        let param = LoginParam::from_database(context, "configured_");
-        // the trailing underscore is correct
-
-        if imap.connect(context, &param) {
-            ret_connected = 2;
-        }
-    }
-
-    ret_connected
-}
-
 /*******************************************************************************
 * Configure a Context
 ******************************************************************************/
--- a/src/context.rs
+++ b/src/context.rs
@@ -44,9 +44,9 @@ pub struct Context {
    /// Blob directory path
    blobdir: PathBuf,
    pub sql: Sql,
-    pub inbox: Arc<RwLock<Imap>>,
    pub perform_inbox_jobs_needed: Arc<RwLock<bool>>,
    pub probe_imap_network: Arc<RwLock<bool>>,
+    pub inbox_thread: Arc<RwLock<JobThread>>,
    pub sentbox_thread: Arc<RwLock<JobThread>>,
    pub mvbox_thread: Arc<RwLock<JobThread>>,
    pub smtp: Arc<Mutex<Smtp>>,
@@ -57,7 +57,7 @@ pub struct Context {
    pub os_name: Option<String>,
    pub cmdline_sel_chat_id: Arc<RwLock<u32>>,
    pub bob: Arc<RwLock<BobStatus>>,
-    pub last_smeared_timestamp: Arc<RwLock<i64>>,
+    pub last_smeared_timestamp: RwLock<i64>,
    pub running_state: Arc<RwLock<RunningState>>,
    /// Mutex to avoid generating the key for the user more than once.
    pub generating_key_mutex: Mutex<()>,
@@ -121,7 +121,6 @@ impl Context {
        let ctx = Context {
            blobdir,
            dbfile,
-            inbox: Arc::new(RwLock::new(Imap::new())),
            cb,
            os_name: Some(os_name),
            running_state: Arc::new(RwLock::new(Default::default())),
@@ -130,8 +129,13 @@ impl Context {
            smtp_state: Arc::new((Mutex::new(Default::default()), Condvar::new())),
            oauth2_critical: Arc::new(Mutex::new(())),
            bob: Arc::new(RwLock::new(Default::default())),
-            last_smeared_timestamp: Arc::new(RwLock::new(0)),
+            last_smeared_timestamp: RwLock::new(0),
            cmdline_sel_chat_id: Arc::new(RwLock::new(0)),
+            inbox_thread: Arc::new(RwLock::new(JobThread::new(
+                "INBOX",
+                "configured_inbox_folder",
+                Imap::new(),
+            ))),
            sentbox_thread: Arc::new(RwLock::new(JobThread::new(
                "SENTBOX",
                "configured_sentbox_folder",
@@ -463,8 +467,8 @@ impl Context {

 impl Drop for Context {
    fn drop(&mut self) {
-        info!(self, "disconnecting INBOX-watch",);
-        self.inbox.read().unwrap().disconnect(self);
+        info!(self, "disconnecting inbox-thread",);
+        self.inbox_thread.read().unwrap().imap.disconnect(self);
        info!(self, "disconnecting sentbox-thread",);
        self.sentbox_thread.read().unwrap().imap.disconnect(self);
        info!(self, "disconnecting mvbox-thread",);
@@ -494,8 +498,6 @@ pub struct BobStatus {
 #[derive(Default, Debug)]
 pub struct SmtpState {
    pub idle: bool,
-    pub suspended: bool,
-    pub doing_jobs: bool,
    pub perform_jobs_needed: i32,
    pub probe_network: bool,
 }
--- a/src/dc_receive_imf.rs
+++ b/src/dc_receive_imf.rs
@@ -799,9 +799,12 @@ unsafe fn handle_reports(
                                    && !of_org_msgid.is_null()
                                    && !(*of_org_msgid).fld_value.is_null()
                                {
-                                    if let Ok(rfc724_mid) = wrapmime::parse_message_id(
-                                        &to_string_lossy((*of_org_msgid).fld_value),
-                                    ) {
+                                    if let Ok(rfc724_mid) =
+                                        wrapmime::parse_message_id(std::slice::from_raw_parts(
+                                            (*of_org_msgid).fld_value as *const u8,
+                                            libc::strlen((*of_org_msgid).fld_value),
+                                        ))
+                                    {
                                        if let Some((chat_id, msg_id)) = message::mdn_from_ext(
                                            context,
                                            from_id,
--- a/src/dc_strencode.rs
+++ b/src/dc_strencode.rs
@@ -38,7 +38,7 @@ pub fn dc_encode_header_words(input: impl AsRef<str>) -> String {
 fn must_encode(byte: u8) -> bool {
    static SPECIALS: &[u8] = b",:!\"#$@[\\]^`{|}~=?_";

-    SPECIALS.into_iter().any(|b| *b == byte)
+    SPECIALS.iter().any(|b| *b == byte)
 }

 fn quote_word(word: &[u8]) -> String {
--- a/src/dc_tools.rs
+++ b/src/dc_tools.rs
@@ -1,7 +1,7 @@
 //! Some tools and enhancements to the used libraries, there should be
 //! no references to Context and other "larger" entities here.

-use core::cmp::max;
+use core::cmp::{max, min};
 use std::borrow::Cow;
 use std::ffi::{CStr, CString};
 use std::path::{Path, PathBuf};
@@ -165,11 +165,26 @@ pub(crate) fn dc_gm2local_offset() -> i64 {
    lt.offset().local_minus_utc() as i64
 }

-/* timesmearing */
+// timesmearing
+// - as e-mails typically only use a second-based-resolution for timestamps,
+//   the order of two mails sent withing one second is unclear.
+//   this is bad eg. when forwarding some messages from a chat -
+//   these messages will appear at the recipient easily out of order.
+// - we work around this issue by not sending out two mails with the same timestamp.
+// - for this purpose, in short, we track the last timestamp used in `last_smeared_timestamp`
+//   when another timestamp is needed in the same second, we use `last_smeared_timestamp+1`
+// - after some moments without messages sent out,
+//   `last_smeared_timestamp` is again in sync with the normal time.
+// - however, we do not do all this for the far future,
+//   but at max `MAX_SECONDS_TO_LEND_FROM_FUTURE`
+const MAX_SECONDS_TO_LEND_FROM_FUTURE: i64 = 5;
+
+// returns the currently smeared timestamp,
+// may be used to check if call to dc_create_smeared_timestamp() is needed or not.
+// the returned timestamp MUST NOT be used to be sent out or saved in the database!
 pub(crate) fn dc_smeared_time(context: &Context) -> i64 {
-    /* function returns a corrected time(NULL) */
    let mut now = time();
-    let ts = *context.last_smeared_timestamp.clone().read().unwrap();
+    let ts = *context.last_smeared_timestamp.read().unwrap();
    if ts >= now {
        now = ts + 1;
    }
@@ -177,32 +192,36 @@ pub(crate) fn dc_smeared_time(context: &Context) -> i64 {
    now
 }

+// returns a timestamp that is guaranteed to be unique.
 pub(crate) fn dc_create_smeared_timestamp(context: &Context) -> i64 {
    let now = time();
    let mut ret = now;

-    let ts = *context.last_smeared_timestamp.clone().write().unwrap();
-    if ret <= ts {
-        ret = ts + 1;
-        if ret - now > 5 {
-            ret = now + 5
+    let mut last_smeared_timestamp = context.last_smeared_timestamp.write().unwrap();
+    if ret <= *last_smeared_timestamp {
+        ret = *last_smeared_timestamp + 1;
+        if ret - now > MAX_SECONDS_TO_LEND_FROM_FUTURE {
+            ret = now + MAX_SECONDS_TO_LEND_FROM_FUTURE
        }
    }

+    *last_smeared_timestamp = ret;
    ret
 }

+// creates `count` timestamps that are guaranteed to be unique.
+// the frist created timestamps is returned directly,
+// get the other timestamps just by adding 1..count-1
 pub(crate) fn dc_create_smeared_timestamps(context: &Context, count: usize) -> i64 {
-    /* get a range to timestamps that can be used uniquely */
    let now = time();
-    let start = now + (if count < 5 { count } else { 5 }) as i64 - count as i64;
+    let count = count as i64;
+    let mut start = now + min(count, MAX_SECONDS_TO_LEND_FROM_FUTURE) - count;

-    let ts = *context.last_smeared_timestamp.clone().write().unwrap();
-    if ts + 1 > start {
-        ts + 1
-    } else {
-        start
-    }
+    let mut last_smeared_timestamp = context.last_smeared_timestamp.write().unwrap();
+    start = max(*last_smeared_timestamp + 1, start);
+
+    *last_smeared_timestamp = start + count - 1;
+    start
 }

 /* Message-ID tools */
@@ -1355,4 +1374,34 @@ mod tests {
        let listflags: u32 = DC_GCL_VERIFIED_ONLY.try_into().unwrap();
        assert!(listflags_has(listflags, DC_GCL_ADD_SELF) == false);
    }
+
+    #[test]
+    fn test_create_smeared_timestamp() {
+        let t = dummy_context();
+        assert_ne!(
+            dc_create_smeared_timestamp(&t.ctx),
+            dc_create_smeared_timestamp(&t.ctx)
+        );
+        assert!(
+            dc_create_smeared_timestamp(&t.ctx)
+                >= SystemTime::now()
+                    .duration_since(SystemTime::UNIX_EPOCH)
+                    .unwrap()
+                    .as_secs() as i64
+        );
+    }
+
+    #[test]
+    fn test_create_smeared_timestamps() {
+        let t = dummy_context();
+        let count = MAX_SECONDS_TO_LEND_FROM_FUTURE - 1;
+        let start = dc_create_smeared_timestamps(&t.ctx, count as usize);
+        let next = dc_smeared_time(&t.ctx);
+        assert!((start + count - 1) < next);
+
+        let count = MAX_SECONDS_TO_LEND_FROM_FUTURE + 30;
+        let start = dc_create_smeared_timestamps(&t.ctx, count as usize);
+        let next = dc_smeared_time(&t.ctx);
+        assert!((start + count - 1) < next);
+    }
 }
--- a/src/e2ee.rs
+++ b/src/e2ee.rs
@@ -498,7 +498,7 @@ fn decrypt_if_autocrypt_message(
    public_keyring_for_validate: &Keyring,
    ret_valid_signatures: &mut HashSet<String>,
    ret_gossip_headers: *mut *mut mailimf_fields,
-) -> Result<(bool)> {
+) -> Result<bool> {
    /* The returned bool is true if we detected an Autocrypt-encrypted
    message and successfully decrypted it. Decryption then modifies the
    passed in mime structure in place. The returned bool is false
--- a/src/error.rs
+++ b/src/error.rs
@@ -34,6 +34,26 @@ pub enum Error {
    BlobError(#[cause] crate::blob::BlobError),
    #[fail(display = "Invalid Message ID.")]
    InvalidMsgId,
+    #[fail(display = "Watch folder not found {:?}", _0)]
+    WatchFolderNotFound(String),
+    #[fail(display = "Connection Failed params: {}", _0)]
+    ImapConnectionFailed(String),
+    #[fail(display = "Could not get OAUTH token")]
+    ImapOauthError,
+    #[fail(display = "Could not login as {}", _0)]
+    ImapLoginFailed(String),
+    #[fail(display = "Cannot idle")]
+    ImapMissesIdle,
+    #[fail(display = "Imap IDLE protocol failed to init/complete")]
+    ImapIdleProtocolFailed(String),
+    #[fail(display = "Imap IDLE failed to select folder {:?}", _0)]
+    ImapSelectFailed(String),
+    #[fail(display = "Connect without configured params")]
+    ConnectWithoutConfigure,
+    #[fail(display = "imap operation attempted while imap is torn down")]
+    ImapInTeardown,
+    #[fail(display = "No IMAP Connection established")]
+    ImapNoConnection,
 }

 pub type Result<T> = std::result::Result<T, Error>;
--- a/src/imap.rs
+++ b/src/imap.rs
--- a/src/imap_client.rs
+++ b/src/imap_client.rs
@@ -0,0 +1,294 @@
+use async_imap::{
+    error::{Error as ImapError, Result as ImapResult},
+    extensions::idle::Handle as ImapIdleHandle,
+    types::{Capabilities, Fetch, Mailbox, Name},
+    Client as ImapClient, Session as ImapSession,
+};
+use async_std::net::{self, TcpStream};
+use async_std::prelude::*;
+use async_std::sync::Arc;
+use async_tls::client::TlsStream;
+
+use crate::login_param::{dc_build_tls_config, CertificateChecks};
+
+const DCC_IMAP_DEBUG: &str = "DCC_IMAP_DEBUG";
+
+#[derive(Debug)]
+pub(crate) enum Client {
+    Secure(ImapClient<TlsStream<TcpStream>>),
+    Insecure(ImapClient<TcpStream>),
+}
+
+#[derive(Debug)]
+pub(crate) enum Session {
+    Secure(ImapSession<TlsStream<TcpStream>>),
+    Insecure(ImapSession<TcpStream>),
+}
+
+#[derive(Debug)]
+pub(crate) enum IdleHandle {
+    Secure(ImapIdleHandle<TlsStream<TcpStream>>),
+    Insecure(ImapIdleHandle<TcpStream>),
+}
+
+impl Client {
+    pub async fn connect_secure<A: net::ToSocketAddrs, S: AsRef<str>>(
+        addr: A,
+        domain: S,
+        certificate_checks: CertificateChecks,
+    ) -> ImapResult<Self> {
+        let stream = TcpStream::connect(addr).await?;
+        let tls_config = dc_build_tls_config(certificate_checks);
+        let tls_connector: async_tls::TlsConnector = Arc::new(tls_config).into();
+        let tls_stream = tls_connector.connect(domain.as_ref(), stream)?.await?;
+        let mut client = ImapClient::new(tls_stream);
+        if std::env::var(DCC_IMAP_DEBUG).is_ok() {
+            client.debug = true;
+        }
+
+        let _greeting = client
+            .read_response()
+            .await
+            .expect("failed to read greeting");
+
+        Ok(Client::Secure(client))
+    }
+
+    pub async fn connect_insecure<A: net::ToSocketAddrs>(addr: A) -> ImapResult<Self> {
+        let stream = TcpStream::connect(addr).await?;
+
+        let mut client = ImapClient::new(stream);
+        if std::env::var(DCC_IMAP_DEBUG).is_ok() {
+            client.debug = true;
+        }
+        let _greeting = client
+            .read_response()
+            .await
+            .expect("failed to read greeting");
+
+        Ok(Client::Insecure(client))
+    }
+
+    pub async fn secure<S: AsRef<str>>(
+        self,
+        domain: S,
+        _certificate_checks: CertificateChecks,
+    ) -> ImapResult<Client> {
+        match self {
+            Client::Insecure(client) => {
+                let tls = async_tls::TlsConnector::new();
+
+                let client_sec = client.secure(domain, &tls).await?;
+
+                Ok(Client::Secure(client_sec))
+            }
+            // Nothing to do
+            Client::Secure(_) => Ok(self),
+        }
+    }
+
+    pub async fn authenticate<A: async_imap::Authenticator, S: AsRef<str>>(
+        self,
+        auth_type: S,
+        authenticator: &A,
+    ) -> Result<Session, (ImapError, Client)> {
+        match self {
+            Client::Secure(i) => match i.authenticate(auth_type, authenticator).await {
+                Ok(session) => Ok(Session::Secure(session)),
+                Err((err, c)) => Err((err, Client::Secure(c))),
+            },
+            Client::Insecure(i) => match i.authenticate(auth_type, authenticator).await {
+                Ok(session) => Ok(Session::Insecure(session)),
+                Err((err, c)) => Err((err, Client::Insecure(c))),
+            },
+        }
+    }
+
+    pub async fn login<U: AsRef<str>, P: AsRef<str>>(
+        self,
+        username: U,
+        password: P,
+    ) -> Result<Session, (ImapError, Client)> {
+        match self {
+            Client::Secure(i) => match i.login(username, password).await {
+                Ok(session) => Ok(Session::Secure(session)),
+                Err((err, c)) => Err((err, Client::Secure(c))),
+            },
+            Client::Insecure(i) => match i.login(username, password).await {
+                Ok(session) => Ok(Session::Insecure(session)),
+                Err((err, c)) => Err((err, Client::Insecure(c))),
+            },
+        }
+    }
+}
+
+impl Session {
+    pub async fn capabilities(&mut self) -> ImapResult<Capabilities> {
+        let res = match self {
+            Session::Secure(i) => i.capabilities().await?,
+            Session::Insecure(i) => i.capabilities().await?,
+        };
+
+        Ok(res)
+    }
+
+    pub async fn list(
+        &mut self,
+        reference_name: Option<&str>,
+        mailbox_pattern: Option<&str>,
+    ) -> ImapResult<Vec<Name>> {
+        let res = match self {
+            Session::Secure(i) => {
+                i.list(reference_name, mailbox_pattern)
+                    .await?
+                    .collect::<ImapResult<_>>()
+                    .await?
+            }
+            Session::Insecure(i) => {
+                i.list(reference_name, mailbox_pattern)
+                    .await?
+                    .collect::<ImapResult<_>>()
+                    .await?
+            }
+        };
+        Ok(res)
+    }
+
+    pub async fn create<S: AsRef<str>>(&mut self, mailbox_name: S) -> ImapResult<()> {
+        match self {
+            Session::Secure(i) => i.create(mailbox_name).await?,
+            Session::Insecure(i) => i.create(mailbox_name).await?,
+        }
+        Ok(())
+    }
+
+    pub async fn subscribe<S: AsRef<str>>(&mut self, mailbox: S) -> ImapResult<()> {
+        match self {
+            Session::Secure(i) => i.subscribe(mailbox).await?,
+            Session::Insecure(i) => i.subscribe(mailbox).await?,
+        }
+        Ok(())
+    }
+
+    pub async fn close(&mut self) -> ImapResult<()> {
+        match self {
+            Session::Secure(i) => i.close().await?,
+            Session::Insecure(i) => i.close().await?,
+        }
+        Ok(())
+    }
+
+    pub async fn select<S: AsRef<str>>(&mut self, mailbox_name: S) -> ImapResult<Mailbox> {
+        let mbox = match self {
+            Session::Secure(i) => i.select(mailbox_name).await?,
+            Session::Insecure(i) => i.select(mailbox_name).await?,
+        };
+
+        Ok(mbox)
+    }
+
+    pub async fn fetch<S1, S2>(&mut self, sequence_set: S1, query: S2) -> ImapResult<Vec<Fetch>>
+    where
+        S1: AsRef<str>,
+        S2: AsRef<str>,
+    {
+        let res = match self {
+            Session::Secure(i) => {
+                i.fetch(sequence_set, query)
+                    .await?
+                    .collect::<ImapResult<_>>()
+                    .await?
+            }
+            Session::Insecure(i) => {
+                i.fetch(sequence_set, query)
+                    .await?
+                    .collect::<ImapResult<_>>()
+                    .await?
+            }
+        };
+        Ok(res)
+    }
+
+    pub async fn uid_fetch<S1, S2>(&mut self, uid_set: S1, query: S2) -> ImapResult<Vec<Fetch>>
+    where
+        S1: AsRef<str>,
+        S2: AsRef<str>,
+    {
+        let res = match self {
+            Session::Secure(i) => {
+                i.uid_fetch(uid_set, query)
+                    .await?
+                    .collect::<ImapResult<_>>()
+                    .await?
+            }
+            Session::Insecure(i) => {
+                i.uid_fetch(uid_set, query)
+                    .await?
+                    .collect::<ImapResult<_>>()
+                    .await?
+            }
+        };
+
+        Ok(res)
+    }
+
+    pub fn idle(self) -> IdleHandle {
+        match self {
+            Session::Secure(i) => {
+                let h = i.idle();
+                IdleHandle::Secure(h)
+            }
+            Session::Insecure(i) => {
+                let h = i.idle();
+                IdleHandle::Insecure(h)
+            }
+        }
+    }
+
+    pub async fn uid_store<S1, S2>(&mut self, uid_set: S1, query: S2) -> ImapResult<Vec<Fetch>>
+    where
+        S1: AsRef<str>,
+        S2: AsRef<str>,
+    {
+        let res = match self {
+            Session::Secure(i) => {
+                i.uid_store(uid_set, query)
+                    .await?
+                    .collect::<ImapResult<_>>()
+                    .await?
+            }
+            Session::Insecure(i) => {
+                i.uid_store(uid_set, query)
+                    .await?
+                    .collect::<ImapResult<_>>()
+                    .await?
+            }
+        };
+        Ok(res)
+    }
+
+    pub async fn uid_mv<S1: AsRef<str>, S2: AsRef<str>>(
+        &mut self,
+        uid_set: S1,
+        mailbox_name: S2,
+    ) -> ImapResult<()> {
+        match self {
+            Session::Secure(i) => i.uid_mv(uid_set, mailbox_name).await?,
+            Session::Insecure(i) => i.uid_mv(uid_set, mailbox_name).await?,
+        }
+        Ok(())
+    }
+
+    pub async fn uid_copy<S1: AsRef<str>, S2: AsRef<str>>(
+        &mut self,
+        uid_set: S1,
+        mailbox_name: S2,
+    ) -> ImapResult<()> {
+        match self {
+            Session::Secure(i) => i.uid_copy(uid_set, mailbox_name).await?,
+            Session::Insecure(i) => i.uid_copy(uid_set, mailbox_name).await?,
+        }
+
+        Ok(())
+    }
+}
--- a/src/imex.rs
+++ b/src/imex.rs
@@ -51,7 +51,7 @@ pub enum ImexMode {

 /// Import/export things.
 /// For this purpose, the function creates a job that is executed in the IMAP-thread then;
-/// this requires to call dc_perform_imap_jobs() regularly.
+/// this requires to call dc_perform_inbox_jobs() regularly.
 ///
 /// What to do is defined by the _what_ parameter.
 ///
@@ -247,7 +247,7 @@ fn maybe_add_bcc_self_device_msg(context: &Context) -> Result<()> {
             go to the settings and enable \"Send copy to self\"."
                .to_string(),
        );
-        chat::add_device_msg_once(context, "bcc-self-hint", &mut msg)?;
+        chat::add_device_msg(context, Some("bcc-self-hint"), Some(&mut msg))?;
    }
    Ok(())
 }
--- a/src/job.rs
+++ b/src/job.rs
@@ -31,6 +31,13 @@ enum Thread {
    Smtp = 5000,
 }

+#[derive(Debug, Display, Copy, Clone, PartialEq, Eq, FromPrimitive, ToPrimitive)]
+enum TryAgain {
+    Dont,
+    AtOnce,
+    StandardDelay,
+}
+
 impl Default for Thread {
    fn default() -> Self {
        Thread::Unknown
@@ -102,7 +109,7 @@ pub struct Job {
    pub added_timestamp: i64,
    pub tries: i32,
    pub param: Params,
-    pub try_again: i32,
+    try_again: TryAgain,
    pub pending_error: Option<String>,
 }

@@ -136,7 +143,7 @@ impl Job {
            let loginparam = LoginParam::from_database(context, "configured_");
            let connected = context.smtp.lock().unwrap().connect(context, &loginparam);
            if connected.is_err() {
-                self.try_again_later(3, None);
+                self.try_again_later(TryAgain::StandardDelay, None);
                return;
            }
        }
@@ -177,28 +184,12 @@ impl Job {
                        Err(err) => {
                            smtp.disconnect();
                            warn!(context, "smtp failed: {}", err);
-                            self.try_again_later(-1, Some(err.to_string()));
+                            self.try_again_later(TryAgain::AtOnce, Some(err.to_string()));
                        }
                        Ok(()) => {
                            // smtp success, update db ASAP, then delete smtp file
                            if 0 != self.foreign_id {
-                                message::update_msg_state(
-                                    context,
-                                    MsgId::new(self.foreign_id),
-                                    MessageState::OutDelivered,
-                                );
-                                let chat_id: i32 = context
-                                    .sql
-                                    .query_get_value(
-                                        context,
-                                        "SELECT chat_id FROM msgs WHERE id=?",
-                                        params![self.foreign_id as i32],
-                                    )
-                                    .unwrap_or_default();
-                                context.call_cb(Event::MsgDelivered {
-                                    chat_id: chat_id as u32,
-                                    msg_id: MsgId::new(self.foreign_id),
-                                });
+                                set_delivered(context, MsgId::new(self.foreign_id));
                            }
                            // now also delete the generated file
                            dc_delete_file(context, filename);
@@ -212,14 +203,14 @@ impl Job {
    }

    // this value does not increase the number of tries
-    fn try_again_later(&mut self, try_again: i32, pending_error: Option<String>) {
+    fn try_again_later(&mut self, try_again: TryAgain, pending_error: Option<String>) {
        self.try_again = try_again;
        self.pending_error = pending_error;
    }

    #[allow(non_snake_case)]
    fn do_DC_JOB_MOVE_MSG(&mut self, context: &Context) {
-        let inbox = context.inbox.read().unwrap();
+        let imap_inbox = &context.inbox_thread.read().unwrap().imap;

        if let Ok(msg) = Message::load_from_db(context, MsgId::new(self.foreign_id)) {
            if context
@@ -228,7 +219,7 @@ impl Job {
                .unwrap_or_default()
                < 3
            {
-                inbox.configure_folders(context, 0x1i32);
+                imap_inbox.configure_folders(context, 0x1i32);
            }
            let dest_folder = context
                .sql
@@ -238,17 +229,17 @@ impl Job {
                let server_folder = msg.server_folder.as_ref().unwrap();
                let mut dest_uid = 0;

-                match inbox.mv(
+                match imap_inbox.mv(
                    context,
                    server_folder,
                    msg.server_uid,
                    &dest_folder,
                    &mut dest_uid,
                ) {
-                    ImapResult::RetryLater => {
-                        self.try_again_later(3i32, None);
+                    ImapActionResult::RetryLater => {
+                        self.try_again_later(TryAgain::StandardDelay, None);
                    }
-                    ImapResult::Success => {
+                    ImapActionResult::Success => {
                        message::update_server_uid(
                            context,
                            &msg.rfc724_mid,
@@ -256,7 +247,7 @@ impl Job {
                            dest_uid,
                        );
                    }
-                    ImapResult::Failed | ImapResult::AlreadyDone => {}
+                    ImapActionResult::Failed | ImapActionResult::AlreadyDone => {}
                }
            }
        }
@@ -264,7 +255,7 @@ impl Job {

    #[allow(non_snake_case)]
    fn do_DC_JOB_DELETE_MSG_ON_IMAP(&mut self, context: &Context) {
-        let inbox = context.inbox.read().unwrap();
+        let imap_inbox = &context.inbox_thread.read().unwrap().imap;

        if let Ok(mut msg) = Message::load_from_db(context, MsgId::new(self.foreign_id)) {
            if !msg.rfc724_mid.is_empty() {
@@ -279,9 +270,10 @@ impl Job {
                    we delete the message from the server */
                    let mid = msg.rfc724_mid;
                    let server_folder = msg.server_folder.as_ref().unwrap();
-                    let res = inbox.delete_msg(context, &mid, server_folder, &mut msg.server_uid);
-                    if res == ImapResult::RetryLater {
-                        self.try_again_later(-1i32, None);
+                    let res =
+                        imap_inbox.delete_msg(context, &mid, server_folder, &mut msg.server_uid);
+                    if res == ImapActionResult::RetryLater {
+                        self.try_again_later(TryAgain::AtOnce, None);
                        return;
                    }
                }
@@ -292,32 +284,32 @@ impl Job {

    #[allow(non_snake_case)]
    fn do_DC_JOB_EMPTY_SERVER(&mut self, context: &Context) {
-        let inbox = context.inbox.read().unwrap();
+        let imap_inbox = &context.inbox_thread.read().unwrap().imap;
        if self.foreign_id & DC_EMPTY_MVBOX > 0 {
            if let Some(mvbox_folder) = context
                .sql
                .get_raw_config(context, "configured_mvbox_folder")
            {
-                inbox.empty_folder(context, &mvbox_folder);
+                imap_inbox.empty_folder(context, &mvbox_folder);
            }
        }
        if self.foreign_id & DC_EMPTY_INBOX > 0 {
-            inbox.empty_folder(context, "INBOX");
+            imap_inbox.empty_folder(context, "INBOX");
        }
    }

    #[allow(non_snake_case)]
    fn do_DC_JOB_MARKSEEN_MSG_ON_IMAP(&mut self, context: &Context) {
-        let inbox = context.inbox.read().unwrap();
+        let imap_inbox = &context.inbox_thread.read().unwrap().imap;

        if let Ok(msg) = Message::load_from_db(context, MsgId::new(self.foreign_id)) {
            let folder = msg.server_folder.as_ref().unwrap();
-            match inbox.set_seen(context, folder, msg.server_uid) {
-                ImapResult::RetryLater => {
-                    self.try_again_later(3i32, None);
+            match imap_inbox.set_seen(context, folder, msg.server_uid) {
+                ImapActionResult::RetryLater => {
+                    self.try_again_later(TryAgain::StandardDelay, None);
                }
-                ImapResult::AlreadyDone => {}
-                ImapResult::Success | ImapResult::Failed => {
+                ImapActionResult::AlreadyDone => {}
+                ImapActionResult::Success | ImapActionResult::Failed => {
                    // XXX the message might just have been moved
                    // we want to send out an MDN anyway
                    // The job will not be retried so locally
@@ -342,9 +334,9 @@ impl Job {
            .unwrap_or_default()
            .to_string();
        let uid = self.param.get_int(Param::ServerUid).unwrap_or_default() as u32;
-        let inbox = context.inbox.read().unwrap();
-        if inbox.set_seen(context, &folder, uid) == ImapResult::RetryLater {
-            self.try_again_later(3i32, None);
+        let imap_inbox = &context.inbox_thread.read().unwrap().imap;
+        if imap_inbox.set_seen(context, &folder, uid) == ImapActionResult::RetryLater {
+            self.try_again_later(TryAgain::StandardDelay, None);
            return;
        }
        if 0 != self.param.get_int(Param::AlsoMove).unwrap_or_default() {
@@ -354,17 +346,17 @@ impl Job {
                .unwrap_or_default()
                < 3
            {
-                inbox.configure_folders(context, 0x1i32);
+                imap_inbox.configure_folders(context, 0x1i32);
            }
            let dest_folder = context
                .sql
                .get_raw_config(context, "configured_mvbox_folder");
            if let Some(dest_folder) = dest_folder {
                let mut dest_uid = 0;
-                if ImapResult::RetryLater
-                    == inbox.mv(context, &folder, uid, &dest_folder, &mut dest_uid)
+                if ImapActionResult::RetryLater
+                    == imap_inbox.mv(context, &folder, uid, &dest_folder, &mut dest_uid)
                {
-                    self.try_again_later(3, None);
+                    self.try_again_later(TryAgain::StandardDelay, None);
                }
            }
        }
@@ -382,45 +374,14 @@ pub fn job_kill_action(context: &Context, action: Action) -> bool {
    .is_ok()
 }

-pub fn perform_imap_fetch(context: &Context) {
-    let inbox = context.inbox.read().unwrap();
-    let start = std::time::Instant::now();
+pub fn perform_inbox_fetch(context: &Context) {
+    let use_network = context.get_config_bool(Config::InboxWatch);

-    if 0 == connect_to_inbox(context, &inbox) {
-        return;
-    }
-    if !context.get_config_bool(Config::InboxWatch) {
-        info!(context, "INBOX-watch disabled.",);
-        return;
-    }
-    info!(context, "INBOX-fetch started...",);
-    inbox.fetch(context);
-    if inbox.should_reconnect() {
-        info!(context, "INBOX-fetch aborted, starting over...",);
-        inbox.fetch(context);
-    }
-    info!(
-        context,
-        "INBOX-fetch done in {:.4} ms.",
-        start.elapsed().as_nanos() as f64 / 1_000_000.0,
-    );
-}
-
-pub fn perform_imap_idle(context: &Context) {
-    let inbox = context.inbox.read().unwrap();
-
-    connect_to_inbox(context, &inbox);
-
-    if *context.perform_inbox_jobs_needed.clone().read().unwrap() {
-        info!(
-            context,
-            "INBOX-IDLE will not be started because of waiting jobs."
-        );
-        return;
-    }
-    info!(context, "INBOX-IDLE started...");
-    inbox.idle(context);
-    info!(context, "INBOX-IDLE ended.");
+    context
+        .inbox_thread
+        .write()
+        .unwrap()
+        .fetch(context, use_network);
 }

 pub fn perform_mvbox_fetch(context: &Context) {
@@ -433,20 +394,6 @@ pub fn perform_mvbox_fetch(context: &Context) {
        .fetch(context, use_network);
 }

-pub fn perform_mvbox_idle(context: &Context) {
-    let use_network = context.get_config_bool(Config::MvboxWatch);
-
-    context
-        .mvbox_thread
-        .read()
-        .unwrap()
-        .idle(context, use_network);
-}
-
-pub fn interrupt_mvbox_idle(context: &Context) {
-    context.mvbox_thread.read().unwrap().interrupt_idle(context);
-}
-
 pub fn perform_sentbox_fetch(context: &Context) {
    let use_network = context.get_config_bool(Config::SentboxWatch);

@@ -457,6 +404,33 @@ pub fn perform_sentbox_fetch(context: &Context) {
        .fetch(context, use_network);
 }

+pub fn perform_inbox_idle(context: &Context) {
+    if *context.perform_inbox_jobs_needed.clone().read().unwrap() {
+        info!(
+            context,
+            "INBOX-IDLE will not be started because of waiting jobs."
+        );
+        return;
+    }
+    let use_network = context.get_config_bool(Config::InboxWatch);
+
+    context
+        .inbox_thread
+        .read()
+        .unwrap()
+        .idle(context, use_network);
+}
+
+pub fn perform_mvbox_idle(context: &Context) {
+    let use_network = context.get_config_bool(Config::MvboxWatch);
+
+    context
+        .mvbox_thread
+        .read()
+        .unwrap()
+        .idle(context, use_network);
+}
+
 pub fn perform_sentbox_idle(context: &Context) {
    let use_network = context.get_config_bool(Config::SentboxWatch);

@@ -467,6 +441,27 @@ pub fn perform_sentbox_idle(context: &Context) {
        .idle(context, use_network);
 }

+pub fn interrupt_inbox_idle(context: &Context, block: bool) {
+    info!(context, "interrupt_inbox_idle called blocking={}", block);
+    if block {
+        context.inbox_thread.read().unwrap().interrupt_idle(context);
+    } else {
+        match context.inbox_thread.try_read() {
+            Ok(inbox_thread) => {
+                inbox_thread.interrupt_idle(context);
+            }
+            Err(err) => {
+                *context.perform_inbox_jobs_needed.write().unwrap() = true;
+                warn!(context, "could not interrupt idle: {}", err);
+            }
+        }
+    }
+}
+
+pub fn interrupt_mvbox_idle(context: &Context) {
+    context.mvbox_thread.read().unwrap().interrupt_idle(context);
+}
+
 pub fn interrupt_sentbox_idle(context: &Context) {
    context
        .sentbox_thread
@@ -484,24 +479,12 @@ pub fn perform_smtp_jobs(context: &Context) {
        state.probe_network = false;
        state.perform_jobs_needed = 0;

-        if state.suspended {
-            info!(context, "SMTP-jobs suspended.",);
-            return;
-        }
-        state.doing_jobs = true;
        probe_smtp_network
    };

    info!(context, "SMTP-jobs started...",);
    job_perform(context, Thread::Smtp, probe_smtp_network);
    info!(context, "SMTP-jobs ended.");
-
-    {
-        let &(ref lock, _) = &*context.smtp_state.clone();
-        let mut state = lock.lock().unwrap();
-
-        state.doing_jobs = false;
-    }
 }

 pub fn perform_smtp_idle(context: &Context) {
@@ -522,7 +505,7 @@ pub fn perform_smtp_idle(context: &Context) {
                let res = cvar.wait_timeout(state, dur).unwrap();
                state = res.0;

-                if state.idle == true || res.1.timed_out() {
+                if state.idle || res.1.timed_out() {
                    // We received the notification and the value has been updated, we can leave.
                    break;
                }
@@ -567,7 +550,7 @@ pub fn maybe_network(context: &Context) {
    }

    interrupt_smtp_idle(context);
-    interrupt_imap_idle(context);
+    interrupt_inbox_idle(context, true);
    interrupt_mvbox_idle(context);
    interrupt_sentbox_idle(context);
 }
@@ -579,6 +562,22 @@ pub fn job_action_exists(context: &Context, action: Action) -> bool {
        .unwrap_or_default()
 }

+fn set_delivered(context: &Context, msg_id: MsgId) {
+    message::update_msg_state(context, msg_id, MessageState::OutDelivered);
+    let chat_id: i32 = context
+        .sql
+        .query_get_value(
+            context,
+            "SELECT chat_id FROM msgs WHERE id=?",
+            params![msg_id],
+        )
+        .unwrap_or_default();
+    context.call_cb(Event::MsgDelivered {
+        chat_id: chat_id as u32,
+        msg_id: msg_id,
+    });
+}
+
 /* special case for DC_JOB_SEND_MSG_TO_SMTP */
 #[allow(non_snake_case)]
 pub fn job_send_msg(context: &Context, msg_id: MsgId) -> Result<(), Error> {
@@ -640,10 +639,12 @@ pub fn job_send_msg(context: &Context, msg_id: MsgId) -> Result<(), Error> {
    }

    if mimefactory.recipients_addr.is_empty() {
-        warn!(
+        // may happen eg. for groups with only SELF and bcc_self disabled
+        info!(
            context,
            "message {} has no recipient, skipping smtp-send", msg_id
        );
+        set_delivered(context, msg_id);
        return Ok(());
    }

@@ -681,15 +682,15 @@ pub fn job_send_msg(context: &Context, msg_id: MsgId) -> Result<(), Error> {
    Ok(())
 }

-pub fn perform_imap_jobs(context: &Context) {
-    info!(context, "dc_perform_imap_jobs starting.",);
+pub fn perform_inbox_jobs(context: &Context) {
+    info!(context, "dc_perform_inbox_jobs starting.",);

    let probe_imap_network = *context.probe_imap_network.clone().read().unwrap();
    *context.probe_imap_network.write().unwrap() = false;
    *context.perform_inbox_jobs_needed.write().unwrap() = false;

    job_perform(context, Thread::Imap, probe_imap_network);
-    info!(context, "dc_perform_imap_jobs ended.",);
+    info!(context, "dc_perform_inbox_jobs ended.",);
 }

 pub fn perform_mvbox_jobs(context: &Context) {
@@ -722,32 +723,31 @@ fn job_perform(context: &Context, thread: Thread, probe_network: bool) {
        params_probe
    };

-    let jobs: Result<Vec<Job>, _> = context.sql.query_map(
-        query,
-        params,
-        |row| {
-            let job = Job {
-                job_id: row.get(0)?,
-                action: row.get(1)?,
-                foreign_id: row.get(2)?,
-                desired_timestamp: row.get(5)?,
-                added_timestamp: row.get(4)?,
-                tries: row.get(6)?,
-                param: row.get::<_, String>(3)?.parse().unwrap_or_default(),
-                try_again: 0,
-                pending_error: None,
-            };
+    let jobs: Result<Vec<Job>, _> = context
+        .sql
+        .query_map(
+            query,
+            params,
+            |row| {
+                let job = Job {
+                    job_id: row.get(0)?,
+                    action: row.get(1)?,
+                    foreign_id: row.get(2)?,
+                    desired_timestamp: row.get(5)?,
+                    added_timestamp: row.get(4)?,
+                    tries: row.get(6)?,
+                    param: row.get::<_, String>(3)?.parse().unwrap_or_default(),
+                    try_again: TryAgain::Dont,
+                    pending_error: None,
+                };

-            Ok(job)
-        },
-        |jobs| jobs.collect::<Result<Vec<Job>, _>>().map_err(Into::into),
-    );
-    match jobs {
-        Ok(ref _res) => {}
-        Err(ref err) => {
-            info!(context, "query failed: {:?}", err);
-        }
-    }
+                Ok(job)
+            },
+            |jobs| jobs.collect::<Result<Vec<Job>, _>>().map_err(Into::into),
+        )
+        .map_err(|err| {
+            warn!(context, "query failed: {:?}", err);
+        });

    for mut job in jobs.unwrap_or_default() {
        info!(
@@ -763,30 +763,15 @@ fn job_perform(context: &Context, thread: Thread, probe_network: bool) {
        );

        // some configuration jobs are "exclusive":
-        // - they are always executed in the imap-thread and the smtp-thread is suspended during execution
-        // - they may change the database handle change the database handle; we do not keep old pointers therefore
        // - they can be re-executed one time AT_ONCE, but they are not save in the database for later execution
        if Action::ConfigureImap == job.action || Action::ImexImap == job.action {
            job_kill_action(context, job.action);
-            context
-                .sentbox_thread
-                .clone()
-                .read()
-                .unwrap()
-                .suspend(context);
-            context
-                .mvbox_thread
-                .clone()
-                .read()
-                .unwrap()
-                .suspend(context);
-            suspend_smtp_thread(context, true);
        }

        let mut tries = 0;
        while tries <= 1 {
            // this can be modified by a job using dc_job_try_again_later()
-            job.try_again = 0;
+            job.try_again = TryAgain::Dont;

            match job.action {
                Action::Unknown => {
@@ -816,39 +801,14 @@ fn job_perform(context: &Context, thread: Thread, probe_network: bool) {
                Action::SendMdnOld => {}
                Action::SendMsgToSmtpOld => {}
            }
-            if job.try_again != -1 {
+            if job.try_again != TryAgain::AtOnce {
                break;
            }
            tries += 1
        }
        if Action::ConfigureImap == job.action || Action::ImexImap == job.action {
-            context
-                .sentbox_thread
-                .clone()
-                .read()
-                .unwrap()
-                .unsuspend(context);
-            context
-                .mvbox_thread
-                .clone()
-                .read()
-                .unwrap()
-                .unsuspend(context);
-            suspend_smtp_thread(context, false);
            break;
-        } else if job.try_again == 2 {
-            // just try over next loop unconditionally, the ui typically interrupts idle when the file (video) is ready
-            info!(
-                context,
-                "{}-job #{} not yet ready and will be delayed.",
-                if thread == Thread::Imap {
-                    "INBOX"
-                } else {
-                    "SMTP"
-                },
-                job.job_id
-            );
-        } else if job.try_again == -1 || job.try_again == 3 {
+        } else if job.try_again == TryAgain::AtOnce || job.try_again == TryAgain::StandardDelay {
            let tries = job.tries + 1;
            if tries < 17 {
                job.tries = tries;
@@ -914,26 +874,6 @@ fn get_backoff_time_offset(c_tries: libc::c_int) -> i64 {
    seconds as i64
 }

-fn suspend_smtp_thread(context: &Context, suspend: bool) {
-    context.smtp_state.0.lock().unwrap().suspended = suspend;
-    if suspend {
-        loop {
-            if !context.smtp_state.0.lock().unwrap().doing_jobs {
-                return;
-            }
-            std::thread::sleep(std::time::Duration::from_micros(300 * 1000));
-        }
-    }
-}
-
-pub fn connect_to_inbox(context: &Context, inbox: &Imap) -> libc::c_int {
-    let ret_connected = dc_connect_to_configured_imap(context, inbox);
-    if 0 != ret_connected {
-        inbox.set_watch_folder("INBOX".into());
-    }
-    ret_connected
-}
-
 fn send_mdn(context: &Context, msg_id: MsgId) -> Result<(), Error> {
    let mut mimefactory = MimeFactory::load_mdn(context, msg_id)?;
    unsafe { mimefactory.render()? };
@@ -1004,7 +944,7 @@ pub fn job_add(
    ).ok();

    match thread {
-        Thread::Imap => interrupt_imap_idle(context),
+        Thread::Imap => interrupt_inbox_idle(context, false),
        Thread::Smtp => interrupt_smtp_idle(context),
        Thread::Unknown => {}
    }
@@ -1020,11 +960,3 @@ pub fn interrupt_smtp_idle(context: &Context) {
    state.idle = true;
    cvar.notify_one();
 }
-
-pub fn interrupt_imap_idle(context: &Context) {
-    info!(context, "Interrupting INBOX-IDLE...",);
-
-    *context.perform_inbox_jobs_needed.write().unwrap() = true;
-
-    context.inbox.read().unwrap().interrupt_idle();
-}
--- a/src/job_thread.rs
+++ b/src/job_thread.rs
@@ -1,7 +1,7 @@
 use std::sync::{Arc, Condvar, Mutex};

-use crate::configure::*;
 use crate::context::Context;
+use crate::error::{Error, Result};
 use crate::imap::Imap;

 #[derive(Debug)]
@@ -16,7 +16,6 @@ pub struct JobThread {
 pub struct JobState {
    idle: bool,
    jobs_needed: bool,
-    suspended: bool,
    using_handle: bool,
 }

@@ -30,32 +29,6 @@ impl JobThread {
        }
    }

-    pub fn suspend(&self, context: &Context) {
-        info!(context, "Suspending {}-thread.", self.name,);
-        {
-            self.state.0.lock().unwrap().suspended = true;
-        }
-        self.interrupt_idle(context);
-        loop {
-            let using_handle = self.state.0.lock().unwrap().using_handle;
-            if !using_handle {
-                return;
-            }
-            std::thread::sleep(std::time::Duration::from_micros(300 * 1000));
-        }
-    }
-
-    pub fn unsuspend(&self, context: &Context) {
-        info!(context, "Unsuspending {}-thread.", self.name);
-
-        let &(ref lock, ref cvar) = &*self.state.clone();
-        let mut state = lock.lock().unwrap();
-
-        state.suspended = false;
-        state.idle = true;
-        cvar.notify_one();
-    }
-
    pub fn interrupt_idle(&self, context: &Context) {
        {
            self.state.0.lock().unwrap().jobs_needed = true;
@@ -77,61 +50,53 @@ impl JobThread {
            let &(ref lock, _) = &*self.state.clone();
            let mut state = lock.lock().unwrap();

-            if state.suspended {
-                return;
-            }
-
            state.using_handle = true;
        }

        if use_network {
-            let start = std::time::Instant::now();
-            if self.connect_to_imap(context) {
-                info!(context, "{}-fetch started...", self.name);
-                self.imap.fetch(context);
-
-                if self.imap.should_reconnect() {
-                    info!(context, "{}-fetch aborted, starting over...", self.name,);
-                    self.imap.fetch(context);
+            if let Err(err) = self.connect_and_fetch(context) {
+                warn!(context, "connect+fetch failed: {}, reconnect & retry", err);
+                self.imap.trigger_reconnect();
+                if let Err(err) = self.connect_and_fetch(context) {
+                    warn!(context, "connect+fetch failed: {}", err);
                }
-                info!(
-                    context,
-                    "{}-fetch done in {:.3} ms.",
-                    self.name,
-                    start.elapsed().as_millis(),
-                );
            }
        }
-
        self.state.0.lock().unwrap().using_handle = false;
    }

-    fn connect_to_imap(&self, context: &Context) -> bool {
-        if self.imap.is_connected() {
-            return true;
-        }
+    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);
+                    let elapsed = start.elapsed().as_millis();
+                    info!(context, "{} done in {:.3} ms.", prefix, elapsed);

-        let mut ret_connected = dc_connect_to_configured_imap(context, &self.imap) != 0;
-
-        if ret_connected {
-            if context
-                .sql
-                .get_raw_config_int(context, "folders_configured")
-                .unwrap_or_default()
-                < 3
-            {
-                self.imap.configure_folders(context, 0x1);
+                    res
+                } else {
+                    Err(Error::WatchFolderNotFound("not-set".to_string()))
+                }
            }
+            Err(err) => Err(err),
+        }
+    }

-            if let Some(mvbox_name) = context.sql.get_raw_config(context, self.folder_config_name) {
-                self.imap.set_watch_folder(mvbox_name);
-            } else {
-                self.imap.disconnect(context);
-                ret_connected = false;
+    fn get_watch_folder(&self, context: &Context) -> Option<String> {
+        match context.sql.get_raw_config(context, self.folder_config_name) {
+            Some(name) => Some(name),
+            None => {
+                if self.folder_config_name == "configured_inbox_folder" {
+                    // initialized with old version, so has not set configured_inbox_folder
+                    Some("INBOX".to_string())
+                } else {
+                    None
+                }
            }
        }
-
-        ret_connected
    }

    pub fn idle(&self, context: &Context, use_network: bool) {
@@ -149,14 +114,6 @@ impl JobThread {
                return;
            }

-            if state.suspended {
-                while !state.idle {
-                    state = cvar.wait(state).unwrap();
-                }
-                state.idle = false;
-                return;
-            }
-
            state.using_handle = true;

            if !use_network {
@@ -170,10 +127,37 @@ impl JobThread {
            }
        }

-        self.connect_to_imap(context);
-        info!(context, "{}-IDLE started...", self.name,);
-        self.imap.idle(context);
-        info!(context, "{}-IDLE ended.", self.name);
+        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(Error::ImapMissesIdle) => true, // we have to do fake_idle
+                    Err(err) => {
+                        warn!(context, "{} failed: {} -> reconnecting", prefix, err);
+                        // something is borked, let's start afresh on the next occassion
+                        self.imap.disconnect(context);
+
+                        false
+                    }
+                }
+            }
+            Err(err) => {
+                info!(context, "{}-IDLE connection fail: {:?}", self.name, err);
+                // if the connection fails, use fake_idle to retry periodically
+                // fake_idle() will be woken up by interrupt_idle() as
+                // well so will act on maybe_network events
+                true
+            }
+        };
+        if do_fake_idle {
+            let watch_folder = self.get_watch_folder(context);
+            self.imap.fake_idle(context, watch_folder);
+        }

        self.state.0.lock().unwrap().using_handle = false;
    }
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -40,6 +40,7 @@ pub mod contact;
 pub mod context;
 mod e2ee;
 mod imap;
+mod imap_client;
 pub mod imex;
 pub mod job;
 mod job_thread;
--- a/src/location.rs
+++ b/src/location.rs
@@ -304,16 +304,15 @@ pub fn get_range(
    if timestamp_to == 0 {
        timestamp_to = time() + 10;
    }
-
    context
        .sql
        .query_map(
            "SELECT l.id, l.latitude, l.longitude, l.accuracy, l.timestamp, l.independent, \
-             m.id, l.from_id, l.chat_id, m.txt \
+             COALESCE(m.id, 0) AS msg_id, l.from_id, l.chat_id, COALESCE(m.txt, '') AS txt \
             FROM locations l  LEFT JOIN msgs m ON l.id=m.location_id  WHERE (? OR l.chat_id=?) \
             AND (? OR l.from_id=?) \
             AND (l.independent=1 OR (l.timestamp>=? AND l.timestamp<=?)) \
-             ORDER BY l.timestamp DESC, l.id DESC, m.id DESC;",
+             ORDER BY l.timestamp DESC, l.id DESC, msg_id DESC;",
            params![
                if chat_id == 0 { 1 } else { 0 },
                chat_id as i32,
@@ -330,7 +329,6 @@ pub fn get_range(
                } else {
                    None
                };
-
                let loc = Location {
                    location_id: row.get(0)?,
                    latitude: row.get(1)?,
--- a/src/login_param.rs
+++ b/src/login_param.rs
@@ -3,6 +3,10 @@ use std::fmt;

 use crate::context::Context;
 use crate::error::Error;
+use async_std::sync::Arc;
+use rustls;
+use webpki;
+use webpki_roots;

 #[derive(Copy, Clone, Debug, Display, FromPrimitive)]
 #[repr(i32)]
@@ -251,27 +255,49 @@ fn get_readable_flags(flags: i32) -> String {
    res
 }

-pub fn dc_build_tls(
-    certificate_checks: CertificateChecks,
-) -> Result<native_tls::TlsConnector, native_tls::Error> {
-    let mut tls_builder = native_tls::TlsConnector::builder();
+pub struct NoCertificateVerification {}
+
+impl rustls::ServerCertVerifier for NoCertificateVerification {
+    fn verify_server_cert(
+        &self,
+        _roots: &rustls::RootCertStore,
+        _presented_certs: &[rustls::Certificate],
+        _dns_name: webpki::DNSNameRef<'_>,
+        _ocsp: &[u8],
+    ) -> Result<rustls::ServerCertVerified, rustls::TLSError> {
+        Ok(rustls::ServerCertVerified::assertion())
+    }
+}
+
+pub fn dc_build_tls_config(certificate_checks: CertificateChecks) -> rustls::ClientConfig {
+    let mut config = rustls::ClientConfig::new();
+    config
+        .root_store
+        .add_server_trust_anchors(&webpki_roots::TLS_SERVER_ROOTS);
+
    match certificate_checks {
+        CertificateChecks::Strict => {}
        CertificateChecks::Automatic => {
            // Same as AcceptInvalidCertificates for now.
            // TODO: use provider database when it becomes available
-            tls_builder
-                .danger_accept_invalid_hostnames(true)
-                .danger_accept_invalid_certs(true)
+            config
+                .dangerous()
+                .set_certificate_verifier(Arc::new(NoCertificateVerification {}));
+        }
+        CertificateChecks::AcceptInvalidCertificates => {
+            // TODO: only accept invalid certs
+            config
+                .dangerous()
+                .set_certificate_verifier(Arc::new(NoCertificateVerification {}));
        }
-        CertificateChecks::Strict => &mut tls_builder,
        CertificateChecks::AcceptInvalidHostnames => {
-            tls_builder.danger_accept_invalid_hostnames(true)
+            // TODO: only accept invalid hostnames
+            config
+                .dangerous()
+                .set_certificate_verifier(Arc::new(NoCertificateVerification {}));
        }
-        CertificateChecks::AcceptInvalidCertificates => tls_builder
-            .danger_accept_invalid_hostnames(true)
-            .danger_accept_invalid_certs(true),
    }
-    .build()
+    config
 }

 #[cfg(test)]
--- a/src/pgp.rs
+++ b/src/pgp.rs
@@ -2,6 +2,7 @@

 use std::collections::{BTreeMap, HashSet};
 use std::convert::TryInto;
+use std::io;
 use std::io::Cursor;

 use pgp::armor::BlockType;
@@ -10,8 +11,10 @@ use pgp::composed::{
    SignedPublicSubKey, SignedSecretKey, SubkeyParamsBuilder,
 };
 use pgp::crypto::{HashAlgorithm, SymmetricKeyAlgorithm};
-use pgp::types::{CompressionAlgorithm, KeyTrait, SecretKeyTrait, StringToKey};
-use rand::thread_rng;
+use pgp::types::{
+    CompressionAlgorithm, KeyTrait, Mpi, PublicKeyTrait, SecretKeyTrait, StringToKey,
+};
+use rand::{thread_rng, CryptoRng, Rng};

 use crate::error::Error;
 use crate::key::*;
@@ -20,6 +23,68 @@ use crate::keyring::*;
 pub const HEADER_AUTOCRYPT: &str = "autocrypt-prefer-encrypt";
 pub const HEADER_SETUPCODE: &str = "passphrase-begin";

+/// A wrapper for rPGP public key types
+#[derive(Debug)]
+enum SignedPublicKeyOrSubkey<'a> {
+    Key(&'a SignedPublicKey),
+    Subkey(&'a SignedPublicSubKey),
+}
+
+impl<'a> KeyTrait for SignedPublicKeyOrSubkey<'a> {
+    fn fingerprint(&self) -> Vec<u8> {
+        match self {
+            Self::Key(k) => k.fingerprint(),
+            Self::Subkey(k) => k.fingerprint(),
+        }
+    }
+
+    fn key_id(&self) -> pgp::types::KeyId {
+        match self {
+            Self::Key(k) => k.key_id(),
+            Self::Subkey(k) => k.key_id(),
+        }
+    }
+
+    fn algorithm(&self) -> pgp::crypto::PublicKeyAlgorithm {
+        match self {
+            Self::Key(k) => k.algorithm(),
+            Self::Subkey(k) => k.algorithm(),
+        }
+    }
+}
+
+impl<'a> PublicKeyTrait for SignedPublicKeyOrSubkey<'a> {
+    fn verify_signature(
+        &self,
+        hash: HashAlgorithm,
+        data: &[u8],
+        sig: &[Mpi],
+    ) -> pgp::errors::Result<()> {
+        match self {
+            Self::Key(k) => k.verify_signature(hash, data, sig),
+            Self::Subkey(k) => k.verify_signature(hash, data, sig),
+        }
+    }
+
+    fn encrypt<R: Rng + CryptoRng>(
+        &self,
+        rng: &mut R,
+        plain: &[u8],
+    ) -> pgp::errors::Result<Vec<Mpi>> {
+        match self {
+            Self::Key(k) => k.encrypt(rng, plain),
+            Self::Subkey(k) => k.encrypt(rng, plain),
+        }
+    }
+
+    fn to_writer_old(&self, writer: &mut impl io::Write) -> pgp::errors::Result<()> {
+        match self {
+            Self::Key(k) => k.to_writer_old(writer),
+            Self::Subkey(k) => k.to_writer_old(writer),
+        }
+    }
+}
+
 /// Split data from PGP Armored Data as defined in https://tools.ietf.org/html/rfc4880#section-6.2.
 ///
 /// Returns (type, headers, base64 encoded body).
@@ -99,13 +164,28 @@ pub fn create_keypair(addr: impl AsRef<str>) -> Option<(Key, Key)> {
    Some((Key::Public(public_key), Key::Secret(private_key)))
 }

-/// Select subkey of the public key to use for encryption.
+/// Select public key or subkey to use for encryption.
 ///
-/// Currently the first subkey is selected.
-fn select_pk_for_encryption(key: &SignedPublicKey) -> Option<&SignedPublicSubKey> {
-    key.public_subkeys.iter().find(|_k|
-        // TODO: check if it is an encryption subkey
-        true)
+/// First, tries to use subkeys. If none of the subkeys are suitable
+/// for encryption, tries to use primary key. Returns `None` if the public
+/// key cannot be used for encryption.
+///
+/// TODO: take key flags and expiration dates into account
+fn select_pk_for_encryption(key: &SignedPublicKey) -> Option<SignedPublicKeyOrSubkey> {
+    key.public_subkeys
+        .iter()
+        .find(|subkey| subkey.is_encryption_key())
+        .map_or_else(
+            || {
+                // No usable subkey found, try primary key
+                if key.is_encryption_key() {
+                    Some(SignedPublicKeyOrSubkey::Key(key))
+                } else {
+                    None
+                }
+            },
+            |subkey| Some(SignedPublicKeyOrSubkey::Subkey(subkey)),
+        )
 }

 /// Encrypts `plain` text using `public_keys_for_encryption`
@@ -116,7 +196,7 @@ pub fn pk_encrypt(
    private_key_for_signing: Option<&Key>,
 ) -> Result<String, Error> {
    let lit_msg = Message::new_literal_bytes("", plain);
-    let pkeys: Vec<&SignedPublicSubKey> = public_keys_for_encryption
+    let pkeys: Vec<SignedPublicKeyOrSubkey> = public_keys_for_encryption
        .keys()
        .iter()
        .filter_map(|key| {
@@ -126,6 +206,7 @@ pub fn pk_encrypt(
                .and_then(select_pk_for_encryption)
        })
        .collect();
+    let pkeys_refs: Vec<&SignedPublicKeyOrSubkey> = pkeys.iter().collect();

    let mut rng = thread_rng();

@@ -138,9 +219,9 @@ pub fn pk_encrypt(
        lit_msg
            .sign(skey, || "".into(), Default::default())
            .and_then(|msg| msg.compress(CompressionAlgorithm::ZLIB))
-            .and_then(|msg| msg.encrypt_to_keys(&mut rng, Default::default(), &pkeys))
+            .and_then(|msg| msg.encrypt_to_keys(&mut rng, Default::default(), &pkeys_refs))
    } else {
-        lit_msg.encrypt_to_keys(&mut rng, Default::default(), &pkeys)
+        lit_msg.encrypt_to_keys(&mut rng, Default::default(), &pkeys_refs)
    };

    let msg = encrypted_msg?;
--- a/src/smtp.rs
+++ b/src/smtp.rs
@@ -5,7 +5,7 @@ use crate::constants::*;
 use crate::context::Context;
 use crate::error::Error;
 use crate::events::Event;
-use crate::login_param::{dc_build_tls, LoginParam};
+use crate::login_param::{dc_build_tls_config, LoginParam};
 use crate::oauth2::*;

 #[derive(DebugStub)]
@@ -65,8 +65,8 @@ impl Smtp {
        let domain = &lp.send_server;
        let port = lp.send_port as u16;

-        let tls = dc_build_tls(lp.smtp_certificate_checks).unwrap();
-        let tls_parameters = ClientTlsParameters::new(domain.to_string(), tls);
+        let tls_config = dc_build_tls_config(lp.smtp_certificate_checks);
+        let tls_parameters = ClientTlsParameters::new(domain.to_string(), tls_config);

        let (creds, mechanism) = if 0 != lp.server_flags & (DC_LP_AUTH_OAUTH2 as i32) {
            // oauth2
@@ -138,7 +138,7 @@ impl Smtp {

    /// SMTP-Send a prepared mail to recipients.
    /// on successful send out Ok() is returned.
-    pub fn send<'a>(
+    pub fn send(
        &mut self,
        context: &Context,
        recipients: Vec<EmailAddress>,
--- a/src/sql.rs
+++ b/src/sql.rs
@@ -7,6 +7,7 @@ use std::time::Duration;
 use rusqlite::{Connection, OpenFlags, Statement, NO_PARAMS};
 use thread_local_object::ThreadLocal;

+use crate::chat::update_saved_messages_icon;
 use crate::constants::ShowEmails;
 use crate::context::Context;
 use crate::dc_tools::*;
@@ -495,6 +496,7 @@ fn open(
        let mut dbversion = dbversion_before_update;
        let mut recalc_fingerprints = 0;
        let mut update_file_paths = 0;
+        let mut update_icons = false;

        if dbversion < 1 {
            info!(context, "[migration] v1");
@@ -808,19 +810,23 @@ fn open(
            )?;
            sql.set_raw_config_int(context, "dbversion", 55)?;
        }
-        if dbversion < 57 {
-            info!(context, "[migration] v57");
-            // label is a unique name and is currently used for device-messages only.
-            // in contrast to rfc724_mid and other fields, the label is generated on the device
-            // and allows reliable identifications this way.
+        if dbversion < 59 {
+            info!(context, "[migration] v59");
+            // records in the devmsglabels are kept when the message is deleted.
+            // so, msg_id may or may not exist.
            sql.execute(
-                "ALTER TABLE msgs ADD COLUMN label TEXT DEFAULT '';",
-                params![],
+                "CREATE TABLE devmsglabels (id INTEGER PRIMARY KEY AUTOINCREMENT, label TEXT, msg_id INTEGER DEFAULT 0);",
+                NO_PARAMS,
+            )?;
+            sql.execute(
+                "CREATE INDEX devmsglabels_index1 ON devmsglabels (label);",
+                NO_PARAMS,
            )?;
            if exists_before_update && sql.get_raw_config_int(context, "bcc_self").is_none() {
                sql.set_raw_config_int(context, "bcc_self", 1)?;
            }
-            sql.set_raw_config_int(context, "dbversion", 57)?;
+            update_icons = true;
+            sql.set_raw_config_int(context, "dbversion", 59)?;
        }

        // (2) updates that require high-level objects
@@ -873,6 +879,9 @@ fn open(

            sql.set_raw_config(context, "backup_for", None)?;
        }
+        if update_icons {
+            update_saved_messages_icon(context)?;
+        }
    }

    info!(context, "Opened {:?}.", dbfile.as_ref(),);
@@ -1172,41 +1181,6 @@ fn maybe_add_from_param(
 #[cfg(test)]
 mod test {
    use super::*;
-    use indoc::indoc;
-
-    #[test]
-    fn test_literals() {
-        // (a) sql formatted with the rust-multiline-literal will easily fail.
-        let a = "SELECT a\
-                 FROM b";
-        assert_eq!(a, "SELECT aFROM b");
-
-        // (b) if used without the trailing backspace, things are fine.
-        let a = "SELECT a
-                 FROM b";
-        assert_eq!(a, "SELECT a\n                 FROM b");
-
-        // (c) sql formatted with the concat-macro with also easily fail.
-        // also you cannot convince `cargo fmt` to align the statements.
-        let a = concat!("SELECT a", "FROM b");
-        assert_eq!(a, "SELECT aFROM b");
-
-        // (d) the indoc-macro keeps lineends so that spaces are not needed.
-        // sqlite treats the lineends as normal whitespace so things are fine.
-        // also `cargo fmt` does not destroy the layout and there is less boilerplate.
-        let a = indoc!(
-            "SELECT a
-             FROM b"
-        );
-        assert_eq!(a, "SELECT a\nFROM b");
-
-        // (e) when adding a trailing backslash, things will fail, though.
-        let a = indoc!(
-            "SELECT a\
-             FROM b"
-        );
-        assert_eq!(a, "SELECT aFROM b");
-    }

    #[test]
    fn test_maybe_add_file() {
--- a/src/stock.rs
+++ b/src/stock.rs
@@ -112,8 +112,10 @@ pub enum StockMessage {
    Location = 66,
    #[strum(props(fallback = "Sticker"))]
    Sticker = 67,
-    #[strum(props(fallback = "Device Messages"))]
+    #[strum(props(fallback = "Device messages"))]
    DeviceMessages = 68,
+    #[strum(props(fallback = "Saved messages"))]
+    SavedMessages = 69,
 }

 impl StockMessage {
--- a/src/wrapmime.rs
+++ b/src/wrapmime.rs
@@ -49,20 +49,27 @@ pub fn get_ct_subtype(mime: *mut Mailmime) -> Option<String> {
    }
 }

-pub fn parse_message_id(message_id: &str) -> Result<String, Error> {
+pub fn parse_message_id(message_id: &[u8]) -> Result<String, Error> {
    let mut dummy = 0;
-    let c_message_id = CString::new(message_id).unwrap_or_default();
-    let c_ptr = c_message_id.as_ptr();
    let mut rfc724_mid_c = std::ptr::null_mut();
-    if unsafe { mailimf_msg_id_parse(c_ptr, libc::strlen(c_ptr), &mut dummy, &mut rfc724_mid_c) }
-        == MAIL_NO_ERROR as libc::c_int
+    if unsafe {
+        mailimf_msg_id_parse(
+            message_id.as_ptr() as *const libc::c_char,
+            message_id.len(),
+            &mut dummy,
+            &mut rfc724_mid_c,
+        )
+    } == MAIL_NO_ERROR as libc::c_int
        && !rfc724_mid_c.is_null()
    {
        let res = to_string_lossy(rfc724_mid_c);
        unsafe { libc::free(rfc724_mid_c.cast()) };
        Ok(res)
    } else {
-        bail!("could not parse message_id: {}", message_id);
+        bail!(
+            "could not parse message_id: {}",
+            String::from_utf8_lossy(message_id)
+        );
    }
 }

@@ -543,11 +550,11 @@ mod tests {
    #[test]
    fn test_parse_message_id() {
        assert_eq!(
-            parse_message_id("Mr.PRUe8HJBoaO.3whNvLCMFU0@testrun.org").unwrap(),
+            parse_message_id(b"Mr.PRUe8HJBoaO.3whNvLCMFU0@testrun.org").unwrap(),
            "Mr.PRUe8HJBoaO.3whNvLCMFU0@testrun.org"
        );
        assert_eq!(
-            parse_message_id("<Mr.PRUe8HJBoaO.3whNvLCMFU0@testrun.org>").unwrap(),
+            parse_message_id(b"<Mr.PRUe8HJBoaO.3whNvLCMFU0@testrun.org>").unwrap(),
            "Mr.PRUe8HJBoaO.3whNvLCMFU0@testrun.org"
        );
    }
Author	SHA1	Message	Date
B. Petersen	5cfa9cae7b	do not disconnect sentbox and mvbox, they would be connected at once as no longer suspended	2019-11-27 14:53:27 +01:00
B. Petersen	0794da299c	remove thread-suspend	2019-11-27 00:06:32 +01:00
Alexander Krotov	22a0e3fe9c	job: try_again refactoring Introduce TryAgain type with C core constants Make try_again field and method private. Remove try_again == 2 processing, it was never used.	2019-11-26 22:14:34 +01:00
Floris Bruynooghe	e0601bab3d	Leave the avatar in place if it already is in the blobdir	2019-11-25 12:59:55 +01:00
Floris Bruynooghe	69369b02ea	Copy Selfavatar to blobdir and store as proper blob When a new Selfavatar is set the file needs to be copied into the blobdir and as a proper blob it should be stored in the database as $BLOBDIR/$filename. This should fix #868.	2019-11-25 12:59:55 +01:00
B. Petersen	966b9fac49	fix cast to libc::c_char, signed i8 fails eg. on android	2019-11-24 18:12:42 +01:00
holger krekel	e2a86dd803	prepare beta8	2019-11-24 14:41:25 +01:00
holger krekel	1b88cfd053	as recent fixes are merged to async-imap, let's use that cc @link2xt	2019-11-24 16:30:49 +03:00
Alexander Krotov	6412adcfa7	Use forked version of async-imap and imap-proto This attempts to fix fetching when the inbox contains mail with non-utf8 subjects.	2019-11-24 12:05:30 +01:00
holger krekel	76de8f55f2	make ssh fail directly if a password is asked	2019-11-24 01:05:33 +01:00
holger krekel	ae43b83162	random change to test PR	2019-11-24 01:05:33 +01:00
Alexander Krotov	8d81c8c1e0	Do not crash on messages without message-id	2019-11-23 22:52:16 +01:00
Alexander Krotov	1e173524b5	Upgrade to hex 0.4 rpgp depends on hex 0.4. This prevents building two versions of the same library.	2019-11-23 22:51:27 +01:00
B. Petersen	490418d359	add icon source files	2019-11-22 16:27:54 +01:00
B. Petersen	51ef4d82f9	use flatter design and higher resolution for icons	2019-11-22 16:27:54 +01:00
holger krekel	e522920d49	fix the check for not installing bindings (used from CI), and refined rerun policy	2019-11-22 13:54:30 +01:00
holger krekel	47be554aff	adapt README, comment previous python tests out	2019-11-22 12:28:19 +01:00
holger krekel	f44b2a63b0	revert back to split doc and lint	2019-11-22 12:28:19 +01:00
holger krekel	8d4b893658	fix missing renames and tox dep	2019-11-22 12:28:19 +01:00
holger krekel	7e3c61eb41	address @dignifiedquire err.to_string() comment and avoid extra virtualenv building	2019-11-22 12:28:19 +01:00
holger krekel	bb396685ab	some comments fix imap->inbox naming in example	2019-11-22 12:28:19 +01:00
holger krekel	8ef0ea8aea	simplify double-fetching	2019-11-22 12:28:19 +01:00
holger krekel	34c766dc2b	merge JobThread::connect_to_imap with Imap::connect_configured for simplicity	2019-11-22 12:28:19 +01:00
holger krekel	a30fa710ad	resultify fetch and simplify fake_idle	2019-11-22 12:28:19 +01:00
holger krekel	fa01884350	proper handling of IdleResponse codes	2019-11-22 12:28:19 +01:00
holger krekel	eae9ad6f8b	remove context.inbox in favour of a context.inbox_thread following the mvbox_thread and sentbox_thread patterns. Also some streamlining of shutdown logic.	2019-11-22 12:28:19 +01:00
holger krekel	be533fa66a	resultify some imap operations	2019-11-22 12:28:19 +01:00
holger krekel	254b061921	update docs and add a simple manual script to run python/rust tests	2019-11-22 12:28:19 +01:00
holger krekel	cefa03f45b	run doxygen for core docs again	2019-11-22 12:28:19 +01:00
holger krekel	b67203b421	use the reponame in dir builddir to we can distinguish from desktop/android etc	2019-11-22 12:28:19 +01:00
holger krekel	e14c4d0683	re-enable cross, some streamlining of docs	2019-11-22 12:28:19 +01:00
holger krekel	4ed96b16f4	simplify/speedup python tests	2019-11-22 12:28:19 +01:00
holger krekel	932c86bb3b	various cleanups, better parallelism and build-dir structure	2019-11-22 12:28:19 +01:00
holger krekel	590fd53dd4	don't invoke py36/py35 anymore here.	2019-11-22 12:28:19 +01:00
holger krekel	8e7dc5e86f	reconfigure running of rust and python tests	2019-11-22 12:28:19 +01:00
holger krekel	e13ce3140b	introduce a trigger_reconnect helper	2019-11-22 12:28:19 +01:00
holger krekel	2ebb43b613	update deps, in particular async-imap to 0.1.1 which contains the fix by @dignifiedquire that is expected to fix #829	2019-11-22 12:28:19 +01:00
holger krekel	863a70b8fc	new clean try to get circle-ci to work, disable and move gh actions to ci_scripts folder	2019-11-22 12:28:19 +01:00
dignifiedquire	89a4b6fee5	update github actions	2019-11-22 12:28:19 +01:00
holger krekel	0405c945e2	shortcut fetch/idle on mvbox/sentbox if we don't know the folder and prevent busy-looping	2019-11-22 12:28:19 +01:00
holger krekel	5293ea70ae	steramline some teardown decision code, and add webpki_roots for cert-checking	2019-11-22 12:28:19 +01:00
holger krekel	b5cbc97333	also make smtp respect CertificateChecks setting roughly	2019-11-22 12:28:19 +01:00
holger krekel	a867452927	rough integration of async-tls CertChecks (strict and automatic but not more finegrained work)	2019-11-22 12:28:19 +01:00
dignifiedquire	b13ca0d077	update to released versions	2019-11-22 12:28:19 +01:00
holger krekel	c6f4d6d8bd	* fix interrupt_idle by signalling "skip_next_idle_wait" to the potentially concurrently "fn idle" function * fixes double-export issue	2019-11-22 12:28:19 +01:00
holger krekel	8723aa097e	make select_folder return ImapActionResult's and early-return from idle if there is no selected folder	2019-11-22 12:28:19 +01:00
dignifiedquire	97e6bc2be3	bust ci cache, update deps, use a different rust version, remove rustup install	2019-11-22 12:28:19 +01:00
dignifiedquire	2c2555fad9	refactor: drop native-tls	2019-11-22 12:28:19 +01:00
dignifiedquire	f4f69a030a	update docker image	2019-11-22 12:28:19 +01:00
dignifiedquire	86f66f4d78	cleanup imap impl	2019-11-22 12:28:19 +01:00
dignifiedquire	b4e2b69086	update async-imap	2019-11-22 12:28:19 +01:00
dignifiedquire	1a1a59a14e	implement idle again	2019-11-22 12:28:19 +01:00
dignifiedquire	1687e8d26f	it compiles with async-imap, remove local dependency	2019-11-22 12:28:19 +01:00
Alexander Krotov	4b8252e001	Implement public key selection First, try to use subkeys, because they are usually short-term encryption keys. If none of the subkeys are encryption keys, try to use the primary key. rPGP is updated to the master branch because the latest release does not have .is_encryption_key() yet.	2019-11-22 10:20:40 +01:00
Floris Bruynooghe	f505ff03e4	Do not break double file extensions Double extensions are sometimes used to identify files correctly, e.g. .tar.gz or .html.zip. Breaking those extensions is not very nice. This fixes #865.	2019-11-21 22:18:31 +01:00
björn petersen	ff8e282c43	Merge pull request #862 from deltachat/fix-bcc-self mark messages as sent	2019-11-20 15:28:40 +01:00
B. Petersen	e39cb160f9	make messages as sent in groups with only SELF and bcc_self disabled	2019-11-20 02:48:43 +01:00
björn petersen	76ce0c3540	Merge pull request #856 from deltachat/fix-time-smearing fix time smearing	2019-11-19 23:25:11 +01:00
B. Petersen	f7047bbf51	add detailed comments about time-smearing	2019-11-19 22:52:24 +01:00
B. Petersen	c3a53cefb0	fix time smearing if two messages have the same time, this results i all kinds of sorting failures, esp. in non-delta-muas and on forwarding messages. so, no two messages sent out from delta have the same timestamp. normally, this is no problem, but when things are sent too fast, eg. on forwarding, we lend us some time from the future. however, all this did not work because we forgot to write back the modified time, this is fixed by this commit, as well as some cleanup.	2019-11-19 22:23:01 +01:00
björn petersen	a88153954e	Merge pull request #854 from deltachat/tweak-device-msg tweak device messages	2019-11-19 22:19:42 +01:00
Alexander Krotov	4732085421	Fix some clippy warnings	2019-11-19 19:52:13 +01:00
B. Petersen	e4e6a00fe4	rename has_device_msg() to was_device_msg_ever_added() what describes better what the function is doing	2019-11-19 13:21:02 +01:00
B. Petersen	700e10bc0e	use dc_add_device_msg() also to add labels-only, this is clearer as having a function with 'skip' in the name	2019-11-19 13:05:01 +01:00
B. Petersen	2a4c193601	simplify check for existing device-message	2019-11-19 11:56:35 +01:00
B. Petersen	d3fa289f27	streamline dc_add_device_msg_once\|unlabelled() to one function	2019-11-19 11:49:02 +01:00
B. Petersen	1534a07ded	add dc_has_device_msg()	2019-11-18 17:31:03 +01:00
B. Petersen	a4e92694ba	name unlabelled device-messages as such	2019-11-18 16:47:18 +01:00
B. Petersen	035da9e5d7	add dc_skip_device_msg() and belonging tests	2019-11-18 16:47:18 +01:00
B. Petersen	fed6f4ab8a	do not re-add device-messages deleted by the user	2019-11-18 16:47:18 +01:00
Nico de Haen	d7c42f3c98	Use coalesce for optional columns resolves #851	2019-11-17 20:57:50 +01:00
B. Petersen	ad852161f3	higher resolution for device-icon	2019-11-17 20:56:42 +01:00
B. Petersen	e9b2d6a594	adapt tests to saved-messages chat	2019-11-17 20:56:07 +01:00
B. Petersen	f9d2fe710d	rename me-chat to saved-messages, use an appropriate icon	2019-11-17 20:56:07 +01:00