update provider database (#3043 )

* update provider database ran `./src/provider/update.py ../provider-db/_providers/ > src/provider/data.rs` * update changelog
prepare 1.73 (#3042 )
2026-04-17 05:26:42 +03:00 · 2022-01-31 16:07:20 +01:00 · 2022-01-31 15:12:44 +01:00 · 2022-01-31 13:39:48 +01:00 · 2022-01-31 12:03:21 +01:00 · 2022-01-30 20:00:00 +00:00
41 changed files with 2465 additions and 1208 deletions
--- a/.github/mergeable.yml
+++ b/.github/mergeable.yml
@@ -0,0 +1,26 @@
+version: 2
+mergeable:
+  - when: pull_request.*
+    name: "Changelog check"
+    validate:
+      - do: or
+        validate:
+        - do: description
+          must_include:
+            regex: '#skip-changelog'
+        - do: and
+          validate:
+            - do: dependent
+              changed:
+                file: 'src/**'
+                required: ['CHANGELOG.md']
+            - do: dependent
+              changed:
+                file: 'deltachat-ffi/**'
+                required: ['CHANGELOG.md']
+    fail:
+      - do: checks
+        status: 'action_required' 
+        payload:
+          title: Changlog might need an update
+          summary: "Check if CHANGELOG.md needs an update or add #skip-changelog to the PR description."
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,14 +1,86 @@
 # Changelog

-## Unreleased
+## 1.73.0

 ### API changes
+- added `only_fetch_mvbox` config #3028

+### Changes
+- don't watch Sent folder by default #3025
+- use webxdc app name in chatlist/quotes/replies etc. #3027
+- make it possible to cancel message sending by removing the message #3034,
+  this was previosuly removed in 1.71.0 #2939
+- synchronize Seen flags only on watched folders to speed up
+  folder scanning #3041
+- remove direct dependency on `byteorder` crate #3031
+- refactorings #3023 #3013
+- update provider database #3043
+- improve documentation #3017 #3018 #3021
+
+### Fixes
+- fix splitting off text from webxdc messages #3032
+- call slow `delete_expired_imap_messages()` less often #3037
+- make synchronization of Seen status more robust in case unsolicited FETCH
+  result without UID is returned #3022
+- fetch Inbox before scanning folders to ensure iOS does
+  not kill the app before it gets to fetch the Inbox in background #3040
+
+
+## 1.72.0
+
+### Fixes
+- run migrations on backup import #3006
+
+
+## 1.71.0
+
+### API Changes
+- added APIs to handle database passwords: `dc_context_new_closed()`, `dc_context_open()`,
+  `dc_context_is_open()` and `dc_accounts_add_closed_account()` #2956 #2972
+- use second parameter of `dc_imex` to provide backup passphrase #2980
 - added `DC_MSG_WEBXDC`, `dc_send_webxdc_status_update()`,
-  `dc_get_webxdc_status_updates()`, `dc_msg_get_webxdc_blob()`,
-  `dc_msg_get_webxdc_info()`, and `DC_EVENT_WEBXDC_STATUS_UPDATE` #2826
- Removed `mvbox_watch` option. #2906
-  It is automatically enabled whenever `mvbox_move` is enabled.
+  `dc_get_webxdc_status_updates()`, `dc_msg_get_webxdc_blob()`, `dc_msg_get_webxdc_info()`
+  and `DC_EVENT_WEBXDC_STATUS_UPDATE` #2826 #2971 #2975 #2977 #2979 #2993 #2994 #2998 #3001 #3003
+- added `dc_msg_get_parent()` #2984
+- added `dc_msg_force_plaintext()` API for bots #2847
+- allow removing quotes on drafts `dc_msg_set_quote(msg, NULL)` #2950
+- removed `mvbox_watch` option; watching is enabled when `mvbox_move` is enabled #2906
+- removed `inbox_watch` option #2922
+- deprecated `os_name` in `dc_context_new()`, pass `NULL` or an empty string #2956
+
+### Changes
+- start making it possible to write to mailing lists #2736
+- add `hop_info` to `dc_get_info()` #2751 #2914 #2923
+- add information about whether the database is encrypted or not to `dc_get_info()` #3000
+- selfstatus now defaults to empty #2951 #2960
+- validate detached cryptographic signatures as used eg. by Thunderbird #2865
+- do not change the draft's `msg_id` on updates and sending #2887
+- add `imap` table to keep track of message UIDs #2909 #2938
+- replace `SendMsgToSmtp` jobs which stored outgoing messages in blobdir with `smtp` SQL table #2939 #2996
+- sql: enable `auto_vacuum=INCREMENTAL` #2931
+- sql: build rusqlite with sqlcipher #2934
+- synchronize Seen status across devices #2942
+- `dc_preconfigure_keypair` now takes ascii armored keys instead of base64 #2862
+- put removed member in Bcc instead of To in the message about removal #2864
+- improve group updates #2889
+- re-write the blob filename creation loop #2981
+- update provider database (11 Jan 2022) #2959
+- python: allow timeout for internal configure tracker API #2967
+- python: remove API deprecated in Python 3.10 #2907
+- refactorings #2932 #2957 #2947
+- improve tests #2863 #2866 #2881 #2908 #2918 #2901 #2973
+- improve documentation #2880 #2886 #2895
+- improve ci #2919 #2926 #2969 #2999
+
+### Fixes
+- fix leaving groups #2929
+- fix unread count #2861
+- make `add_parts()` not early-exit #2879
+- recognize MS Exchange read receipts as read receipts #2890
+- create parent directory if creating a new file fails #2978
+- save "configured" flag later #2974
+- improve log #2928
+- `dc_receive_imf`: don't fail on invalid address in the To field #2940


 ## 1.70.0
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat"
-version = "1.70.0"
+version = "1.73.0"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"
 license = "MPL-2.0"
@@ -12,6 +12,9 @@ debug = 0
 [profile.release]
 lto = true

+[patch.crates-io]
+rusqlite = { git = "https://github.com/rusqlite/rusqlite", branch="master" }
+
 [dependencies]
 deltachat_derive = { path = "./deltachat_derive" }

@@ -27,7 +30,6 @@ async-trait = "0.1"
 backtrace = "0.3"
 base64 = "0.13"
 bitflags = "1.3"
-byteorder = "1.3"
 chrono = "0.4"
 dirs = { version = "4", optional=true }
 email = { git = "https://github.com/deltachat/rust-email", branch = "master" }
@@ -63,7 +65,7 @@ serde = { version = "1.0", features = ["derive"] }
 sha-1 = "0.10"
 sha2 = "0.10"
 smallvec = "1"
-stop-token = "0.6"
+stop-token = "0.7"
 strum = "0.23"
 strum_macros = "0.23"
 surf = { version = "2.3", default-features = false, features = ["h1-client"] }
@@ -74,7 +76,7 @@ uuid = { version = "0.8", features = ["serde", "v4"] }
 fast-socks5 = "0.4"
 humansize = "1"
 qrcodegen = "1.7.0"
-tagger = "4.0.1"
+tagger = "4.2.1"
 textwrap = "0.14.2"
 zip = { version = "0.5.13", default-features = false, features = ["deflate"] }

--- a/assets/icon-webxdc.png
+++ b/assets/icon-webxdc.png
--- a/assets/icon-webxdc.svg
+++ b/assets/icon-webxdc.svg
@@ -7,90 +7,175 @@
   xmlns="http://www.w3.org/2000/svg"
   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   inkscape:export-ydpi="409.60001"
-   inkscape:export-xdpi="409.60001"
-   inkscape:export-filename="/Users/bpetersen/projects/deltachat-core-rust/assets/icon-webxdc.png"
-   version="1.0"
-   width="60"
-   height="60"
-   viewBox="0 0 45 45"
-   preserveAspectRatio="xMidYMid meet"
-   id="svg4344"
+   width="80mm"
+   height="297mm"
+   viewBox="0 0 80 297"
+   version="1.1"
+   id="svg71"
+   inkscape:version="1.0.2 (e86c8708, 2021-01-15)"
   sodipodi:docname="icon-webxdc.svg"
-   inkscape:version="1.0.2 (e86c8708, 2021-01-15)">
-  <defs
-     id="defs4348" />
+   inkscape:export-filename="C:\Users\user\OneDrive - BFW-Leipzig\Documents\LogoDC\finalohnerand.png"
+   inkscape:export-xdpi="96"
+   inkscape:export-ydpi="96">
+  <metadata
+     id="metadata856">
+    <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></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
  <sodipodi:namedview
-     inkscape:snap-global="false"
-     pagecolor="#ffffff"
+     id="namedview73"
+     pagecolor="#767676"
     bordercolor="#666666"
-     inkscape:document-rotation="0"
-     borderopacity="1"
-     objecttolerance="10"
-     gridtolerance="10"
-     guidetolerance="10"
-     inkscape:pageopacity="0"
+     borderopacity="1.0"
     inkscape:pageshadow="2"
+     inkscape:pageopacity="0"
+     inkscape:pagecheckerboard="true"
+     inkscape:document-units="mm"
+     showgrid="false"
+     showborder="false"
+     inkscape:snap-bbox="true"
+     inkscape:bbox-paths="true"
+     inkscape:bbox-nodes="true"
+     inkscape:snap-bbox-edge-midpoints="true"
+     inkscape:snap-bbox-midpoints="true"
+     inkscape:object-paths="true"
+     inkscape:snap-intersection-paths="true"
+     inkscape:zoom="1.4142136"
+     inkscape:cx="-90.271136"
+     inkscape:cy="-1233.1209"
     inkscape:window-width="1864"
     inkscape:window-height="1027"
-     id="namedview4346"
-     showgrid="false"
-     units="px"
-     inkscape:zoom="7.919596"
-     inkscape:cx="37.391123"
-     inkscape:cy="24.898474"
-     inkscape:window-x="45"
+     inkscape:window-x="56"
     inkscape:window-y="25"
-     inkscape:window-maximized="0"
-     inkscape:current-layer="svg4344" />
-  <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></dc:title>
-  </cc:Work>
-</rdf:RDF>
-</metadata>
-  <rect
-     y="-4.4408921e-16"
-     x="0"
-     height="45"
-     width="45"
-     id="rect860"
-     style="opacity:1;fill:#b2bbbe;fill-opacity:1;stroke-width:0.819271" />
+     inkscape:window-maximized="1"
+     inkscape:current-layer="layer1"
+     inkscape:snap-global="false"
+     showguides="false"
+     inkscape:guide-bbox="true"
+     inkscape:document-rotation="0"
+     units="px">
+    <sodipodi:guide
+       position="-154.76097,641.11689"
+       orientation="0,-1"
+       id="guide21118" />
+    <sodipodi:guide
+       position="-60.286487,633.36619"
+       orientation="0,-1"
+       id="guide21120" />
+  </sodipodi:namedview>
+  <defs
+     id="defs68">
+    <linearGradient
+       id="linearGradient4375">
+      <stop
+         style="stop-color:#364e59;stop-opacity:1;"
+         offset="0"
+         id="stop4377" />
+      <stop
+         style="stop-color:#364e59;stop-opacity:0;"
+         offset="1"
+         id="stop4379" />
+    </linearGradient>
+  </defs>
  <g
-     fill="#000000"
-     stroke="none"
-     style="fill:#ffffff;fill-opacity:1"
-     transform="matrix(0.00255113,0,0,-0.00255113,5.586152,38.200477)"
-     id="g4342">
-    <text
-       xml:space="preserve"
-       style="font-style:normal;font-weight:normal;font-size:6271.73px;line-height:1.25;font-family:sans-serif;fill:#000000;fill-opacity:1;stroke:none;stroke-width:293.987"
-       x="-254.26019"
-       y="-3819.2668"
-       id="text865"
-       transform="scale(1,-1)"><tspan
-         sodipodi:role="line"
-         id="tspan863"
-         x="-254.26019"
-         y="-3819.2668"
-         style="font-size:6271.73px;stroke-width:293.987" /></text>
+     inkscape:label="Ebene 1"
+     inkscape:groupmode="layer"
+     id="layer1">
+    <rect
+       style="fill:#1a1a1a;stroke:#000000;stroke-width:0.167903"
+       id="rect880"
+       width="79.8321"
+       height="79.8321"
+       x="-64.03286"
+       y="-375.9097"
+       ry="0" />
+    <path
+       inkscape:connector-curvature="0"
+       id="path3799-2"
+       d="m -24.089585,-372.59579 c -19.986026,0.24336 -36.196903,16.666 -36.196903,36.67011 0,20.00409 16.210877,36.03233 36.196903,35.78912 19.0024236,-0.076 14.5340713,-10.6146 35.538854,-0.85693 -11.50627538,-17.97454 0.390097,-20.36737 0.658079,-35.81316 0,-20.00411 -16.2108788,-36.03235 -36.196911,-35.78914 z"
+       style="fill:#364e59;fill-opacity:1;stroke:none;stroke-width:1.93355"
+       sodipodi:nodetypes="sscccs" />
+    <path
+       style="fill:none;stroke:#000000;stroke-width:0.264583px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="M -54.193871,-325.26419 Z"
+       id="path3846" />
+    <path
+       style="fill:none;stroke:#000000;stroke-width:0.264583px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="M -49.397951,-326.67773 Z"
+       id="path3848" />
+    <path
+       style="fill:none;stroke:#000000;stroke-width:0.264583px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m -49.397951,-326.67773 v 0 0"
+       id="path3850" />
+    <path
+       style="fill:none;stroke:#000000;stroke-width:0.01;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+       d="m -51.35133,-325.0334 -7.964067,5.98895 z"
+       id="path3965" />
+    <path
+       inkscape:connector-curvature="0"
+       id="path11037"
+       d="m -24.089585,-372.19891 c -19.986026,0.24156 -36.196903,16.54352 -36.196903,36.40062 0,7.86524 2.543315,15.1113 6.857155,20.97971 6.577146,8.94734 11.123515,9.77363 11.123515,9.77363 1.343237,1.78324 10.270932,4.3223 10.270932,4.3223 l 16.791727,-70.86654 -0.468369,-0.33457 c 0.458597,0.26445 0.428277,-0.27515 -8.378035,-0.27515 z"
+       style="fill:#7cc5cc;fill-opacity:1;stroke:none;stroke-width:1.92643"
+       sodipodi:nodetypes="sssccccss" />
+    <path
+       style="fill:none;stroke:#000000;stroke-width:0.264583px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="M -49.944239,-310.69957 Z"
+       id="path13674" />
+    <g
+       id="g15178"
+       transform="matrix(0.79975737,0,0,0.79975737,53.088959,-63.716396)">
+      <rect
+         style="fill:#364e59;fill-opacity:1;stroke-width:0.01;stroke-miterlimit:4;stroke-dasharray:none"
+         id="rect15072"
+         width="29.897917"
+         height="6.8791666"
+         x="-334.4964"
+         y="-154.51025"
+         transform="rotate(45)" />
+      <rect
+         style="fill:#364e59;fill-opacity:1;stroke-width:0.01;stroke-miterlimit:4;stroke-dasharray:none"
+         id="rect15072-5"
+         width="29.897917"
+         height="6.8791666"
+         x="147.63107"
+         y="-334.4964"
+         transform="rotate(-45)"
+         inkscape:transform-center-x="-0.74835017"
+         inkscape:transform-center-y="0.37417525" />
+    </g>
+    <g
+       id="g22468"
+       transform="translate(3.3033974)">
+      <g
+         id="g15178-0"
+         transform="matrix(-0.79975737,0,0,0.79975737,-103.11028,-63.716404)"
+         style="fill:#7cc5cc;fill-opacity:1">
+        <rect
+           style="fill:#7cc5cc;fill-opacity:1;stroke-width:0.01;stroke-miterlimit:4;stroke-dasharray:none"
+           id="rect15072-2"
+           width="29.897917"
+           height="6.8791666"
+           x="-334.4964"
+           y="-154.51025"
+           transform="rotate(45)" />
+        <rect
+           style="fill:#7cc5cc;fill-opacity:1;stroke-width:0.01;stroke-miterlimit:4;stroke-dasharray:none"
+           id="rect15072-5-5"
+           width="29.897917"
+           height="6.8791666"
+           x="147.63107"
+           y="-334.4964"
+           transform="rotate(-45)"
+           inkscape:transform-center-x="-0.74835017"
+           inkscape:transform-center-y="0.37417525" />
+      </g>
+    </g>
  </g>
-  <text
-     xml:space="preserve"
-     style="font-style:normal;font-weight:normal;font-size:18px;line-height:1.25;font-family:sans-serif;fill:#000000;fill-opacity:1;stroke:none;stroke-width:0.75"
-     x="1.125"
-     y="29.20166"
-     id="text869"><tspan
-       sodipodi:role="line"
-       id="tspan867"
-       x="1.125"
-       y="29.20166"
-       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:18px;font-family:sans-serif;-inkscape-font-specification:'sans-serif Bold';stroke-width:0.75">.xdc</tspan></text>
 </svg>
--- a/deltachat-ffi/Cargo.toml
+++ b/deltachat-ffi/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat_ffi"
-version = "1.70.0"
+version = "1.73.0"
 description = "Deltachat FFI"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"
--- a/deltachat-ffi/README.md
+++ b/deltachat-ffi/README.md
@@ -1,5 +1,9 @@
 # Delta Chat C Interface

+## Installation
+
+see `Installing libdeltachat system wide` in [../README.md](../README.md)
+
 ## Documentation

 To generate the C Interface documentation,
--- a/deltachat-ffi/deltachat.h
+++ b/deltachat-ffi/deltachat.h
@@ -335,14 +335,20 @@ char*           dc_get_blobdir               (const dc_context_t* context);
 *                    1=send a copy of outgoing messages to self.
 *                    Sending messages to self is needed for a proper multi-account setup,
 *                    however, on the other hand, may lead to unwanted notifications in non-delta clients.
- * - `sentbox_watch`= 1=watch `Sent`-folder for changes (default),
- *                    0=do not watch the `Sent`-folder,
+ * - `sentbox_watch`= 1=watch `Sent`-folder for changes,
+ *                    0=do not watch the `Sent`-folder (default),
 *                    changes require restarting IO by calling dc_stop_io() and then dc_start_io().
 * - `mvbox_move`   = 1=detect chat messages,
 *                    move them to the `DeltaChat` folder,
 *                    and watch the `DeltaChat` folder for updates (default),
 *                    0=do not move chat-messages
 *                    changes require restarting IO by calling dc_stop_io() and then dc_start_io().
+ * - `only_fetch_mvbox`
+ *                  = 1=Do not fetch messages from folders other than the
+ *                      `DeltaChat` folder. Messages will still be fetched from the
+ *                       spam folder and `sendbox_watch` will also still be respected
+ *                       if enabled.
+ *                    0=watch all folders normally (default)
 * - `show_emails`  = DC_SHOW_EMAILS_OFF (0)=
 *                    show direct replies to chats only (default),
 *                    DC_SHOW_EMAILS_ACCEPTED_CONTACTS (1)=
@@ -2023,8 +2029,8 @@ dc_contact_t*   dc_get_contact               (dc_context_t* context, uint32_t co

 #define         DC_IMEX_EXPORT_SELF_KEYS      1 // param1 is a directory where the keys are written to
 #define         DC_IMEX_IMPORT_SELF_KEYS      2 // param1 is a directory where the keys are searched in and read from
-#define         DC_IMEX_EXPORT_BACKUP        11 // param1 is a directory where the backup is written to
-#define         DC_IMEX_IMPORT_BACKUP        12 // param1 is the file with the backup to import
+#define         DC_IMEX_EXPORT_BACKUP        11 // param1 is a directory where the backup is written to, param2 is a passphrase to encrypt the backup
+#define         DC_IMEX_IMPORT_BACKUP        12 // param1 is the file with the backup to import, param2 is the backup's passphrase


 /**
@@ -2033,14 +2039,16 @@ dc_contact_t*   dc_get_contact               (dc_context_t* context, uint32_t co
 * if needed stop IO using dc_accounts_stop_io() or dc_stop_io() first.
 * What to do is defined by the _what_ parameter which may be one of the following:
 *
- * - **DC_IMEX_EXPORT_BACKUP** (11) - Export a backup to the directory given as `param1`.
+ * - **DC_IMEX_EXPORT_BACKUP** (11) - Export a backup to the directory given as `param1`
+ *   encrypted with the passphrase given as `param2`. If `param2` is NULL or empty string,
+ *   the backup is not encrypted.
 *   The backup contains all contacts, chats, images and other data and device independent settings.
 *   The backup does not contain device dependent settings as ringtones or LED notification settings.
 *   The name of the backup is typically `delta-chat-<day>.tar`, if more than one backup is create on a day,
 *   the format is `delta-chat-<day>-<number>.tar`
 *
- * - **DC_IMEX_IMPORT_BACKUP** (12) - `param1` is the file (not: directory) to import. The file is normally
- *   created by DC_IMEX_EXPORT_BACKUP and detected by dc_imex_has_backup(). Importing a backup
+ * - **DC_IMEX_IMPORT_BACKUP** (12) - `param1` is the file (not: directory) to import. `param2` is the passphrase.
+ *   The file is normally created by DC_IMEX_EXPORT_BACKUP and detected by dc_imex_has_backup(). Importing a backup
 *   is only possible as long as the context is not configured or used in another way.
 *
 * - **DC_IMEX_EXPORT_SELF_KEYS** (1) - Export all private keys and all public keys of the user to the
@@ -3701,6 +3709,9 @@ char*             dc_msg_get_webxdc_blob      (const dc_msg_t* msg, const char*
 *   To get the file, use dc_msg_get_webxdc_blob().
 *   App icons should should be square,
 *   the implementations will add round corners etc. as needed.
+ * - summary: short string describing the state of the app,
+ *   sth. as "2 votes", "Highscore: 123",
+ *   can be changed by the apps and defaults to an empty string.
 *
 * @memberof dc_msg_t
 * @param msg The webxdc instance.
@@ -3962,8 +3973,11 @@ int             dc_msg_is_forwarded           (const dc_msg_t* msg);
 * These messages are typically shown in the center of the chat view,
 * dc_msg_get_text() returns a descriptive text about what is going on.
 *
+ * For informational messages created by Webxdc apps,
+ * dc_msg_get_parent() usually returns the Webxdc instance;
+ * UIs can use that to scroll to the Webxdc app when the info is tapped.
+ *
 * There is no need to perform any action when seeing such a message - this is already done by the core.
- * Typically, these messages are displayed in the center of the chat.
 *
 * @memberof dc_msg_t
 * @param msg The message object.
@@ -4364,6 +4378,23 @@ char*           dc_msg_get_quoted_text        (const dc_msg_t* msg);
 */
 dc_msg_t*       dc_msg_get_quoted_msg         (const dc_msg_t* msg);

+/**
+ * Get parent message, if available.
+ *
+ * Used for Webxdc-info-messages
+ * to jump to the corresponding instance that created the info message.
+ *
+ * For quotes, please use the more specialized
+ * dc_msg_get_quoted_text() and dc_msg_get_quoted_msg().
+ *
+ * @memberof dc_msg_t
+ * @param msg The message object.
+ * @return The parent message or NULL.
+ *     Must be freed using dc_msg_unref() after usage.
+ */
+dc_msg_t*       dc_msg_get_parent             (const dc_msg_t* msg);
+
+
 /**
 * Force the message to be sent in plain text.
 *
--- a/deltachat-ffi/src/lib.rs
+++ b/deltachat-ffi/src/lib.rs
@@ -2022,7 +2022,7 @@ pub unsafe extern "C" fn dc_imex(
    context: *mut dc_context_t,
    what_raw: libc::c_int,
    param1: *const libc::c_char,
-    _param2: *const libc::c_char,
+    param2: *const libc::c_char,
 ) {
    if context.is_null() {
        eprintln!("ignoring careless call to dc_imex()");
@@ -2035,12 +2035,13 @@ pub unsafe extern "C" fn dc_imex(
            return;
        }
    };
+    let passphrase = to_opt_string_lossy(param2);

    let ctx = &*context;

    if let Some(param1) = to_opt_string_lossy(param1) {
        spawn(async move {
-            imex::imex(ctx, what, param1.as_ref())
+            imex::imex(ctx, what, param1.as_ref(), passphrase)
                .await
                .log_err(ctx, "IMEX failed")
        });
@@ -3594,6 +3595,29 @@ pub unsafe extern "C" fn dc_msg_get_quoted_msg(msg: *const dc_msg_t) -> *mut dc_
    }
 }

+#[no_mangle]
+pub unsafe extern "C" fn dc_msg_get_parent(msg: *const dc_msg_t) -> *mut dc_msg_t {
+    if msg.is_null() {
+        eprintln!("ignoring careless call to dc_msg_get_parent()");
+        return ptr::null_mut();
+    }
+    let ffi_msg: &MessageWrapper = &*msg;
+    let context = &*ffi_msg.context;
+    let res = block_on(async move {
+        ffi_msg
+            .message
+            .parent(context)
+            .await
+            .log_err(context, "failed to get parent message")
+            .unwrap_or(None)
+    });
+
+    match res {
+        Some(message) => Box::into_raw(Box::new(MessageWrapper { context, message })),
+        None => ptr::null_mut(),
+    }
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_msg_force_plaintext(msg: *mut dc_msg_t) {
    if msg.is_null() {
--- a/draft/webxdc-dev-reference.md
+++ b/draft/webxdc-dev-reference.md
@@ -3,6 +3,8 @@
 ## Webxdc File Format

 - a **Webxdc app** is a **ZIP-file** with the extension `.xdc`
+- the ZIP-file must use the default compression methods as of RFC 1950,
+  this is "Deflate" or "Store"
 - the ZIP-file must contain at least the file `index.html`
 - if the Webxdc app is started, `index.html` is opened in a restricted webview
  that allow accessing resources only from the ZIP-file
@@ -21,19 +23,34 @@ no need to add `webxdc.js` to your ZIP-file):
 ### sendUpdate()

 ```js
-window.webxdc.sendUpdate(payload, descr);
+window.webxdc.sendUpdate(update, descr);
 ```

 Webxdc apps are usually shared in a chat and run independently on each peer.
 To get a shared state, the peers use `sendUpdate()` to send updates to each other.

- `payload`: any javascript primitive, array or object.
+- `update`: an object with the following fields:  
+    - `update.payload`: any javascript primitive, array or object.
+    - `update.info`: optional, short, informational message that will be added to the chat,
+       eg. "Alice voted" or "Bob scored 123 in MyGame";
+       usually only one line of text is shown,
+       use this option sparingly to not spam the chat.
+    - `update.summary`: optional, short text, shown beside app icon;
+       it is recommended to use some aggregated value,  eg. "8 votes", "Highscore: 123"
+
 - `descr`: short, human-readable description what this update is about.
  this is shown eg. as a fallback text in an email program.

 All peers, including the sending one,
 will receive the update by the callback given to `setUpdateListener()`.

+There are situations where the user cannot send messages to a chat,
+eg. contact requests or if the user has left a group.
+In these cases, you can still call `sendUpdate()`,
+however, the update won't be sent to other peers
+and you won't get the update by `setUpdateListener()` nor by `getAllUpdates()`.
+
+
 ### setUpdateListener()

 ```js
@@ -43,46 +60,54 @@ window.webxdc.setUpdateListener((update) => {});
 With `setUpdateListener()` you define a callback that receives the updates
 sent by `sendUpdate()`.

- `update`: passed to the callback on updates.
- `update.payload`: equals the payload given to `sendUpdate()`
+- `update`: passed to the callback on updates with the following fields:  
+  `update.payload`: equals the payload given to `sendUpdate()`

 The callback is called for updates sent by you or other peers.


 ### getAllUpdates()

-```
-payloads = window.webxdc.getAllUpdates()
+```js
+updates = await window.webxdc.getAllUpdates();
 ```

 In case your Webxdc was just started,
 you may want to reconstruct the state from the last run -
 and also incorporate updates that may have arrived while the app was not running.

- `payloads`: the function returns all previous updates in an array, 
+- `updates`: All previous updates in an array, 
  eg. `[{payload: "foo"},{payload: "bar"}]`
-  if `webxdc.sendUpdate("foo"); webxdc.sendUpdate("bar");` was called on the last run.
+  if `webxdc.sendUpdate({payload: "foo"}); webxdc.sendUpdate({payload: "bar"};` was called on the last run.

-
-### selfAddr()
+The updates are wrapped into a Promise that you can `await` for.
+If you are not in an async function and cannot use `await` therefore,
+you can get the updates with `then()`:

 ```js
-addr = window.webxdc.selfAddr()
+window.webxdc.getAllUpdates().then(updates => {});
 ```

-Returns the peer's own address.
+
+### selfAddr
+
+```js
+window.webxdc.selfAddr
+```
+
+Property with the peer's own address.
 This is esp. useful if you want to differ between different peers -
 just send the address along with the payload,
 and, if needed, compare the payload addresses against selfAddr() later on.


-### selfName()
+### selfName

 ```js
-addr = window.webxdc.selfName()
+window.webxdc.selfName
 ```

-Returns the peer's own name.
+Property with the peer's own name.
 This is name chosen by the user in their settings,
 if there is nothing set, that defaults to the peer's address.

@@ -111,7 +136,7 @@ round corners etc. will be added by the implementations as needed.
 If no icon is set, a default icon will be used.


-## Webxdc Example
+## Webxdc Examples

 The following example shows an input field and  every input is show on all peers.

@@ -130,7 +155,7 @@ The following example shows an input field and  every input is show on all peers
    
      function sendMsg() {
        msg = document.getElementById("input").value;
-        window.webxdc.sendUpdate(msg, 'Someone typed "'+msg+'".');
+        window.webxdc.sendUpdate({payload: msg}, 'Someone typed "'+msg+'".');
      }
    
      function receiveUpdate(update) {
@@ -138,14 +163,26 @@ The following example shows an input field and  every input is show on all peers
      }
    
      window.webxdc.setUpdateListener(receiveUpdate);
-      window.webxdc.getAllUpdates().forEach(receiveUpdate);
+      window.webxdc.getAllUpdates().then(updates => updates.forEach(receiveUpdate));

    </script>
  </body>
 </html>
 ```

-For a more advanved example, see https://github.com/r10s/webxdc-poll/ .
+[Webxdc Development Tool](https://github.com/deltachat/webxdc-dev)
+offers an **Webxdc Simulator** that can be used in many browsers without any installation needed.
+You can also use that repository as a template for your own app -
+just clone and start adapting things to your need.
+
+
+### Advanced Examples
+
+- [2048](https://github.com/adbenitez/2048.xdc)
+- [Draw](https://github.com/adbenitez/draw.xdc)
+- [Poll](https://github.com/r10s/webxdc-poll/)
+- [Tic Tac Toe](https://github.com/Simon-Laux/tictactoe.xdc)
+- Even more with [Topic #webxdc on Github](https://github.com/topics/webxdc)


 ## Closing Remarks
--- a/examples/repl/cmdline.rs
+++ b/examples/repl/cmdline.rs
@@ -472,20 +472,32 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
        }
        "export-backup" => {
            let dir = dirs::home_dir().unwrap_or_default();
-            imex(&context, ImexMode::ExportBackup, dir.as_ref()).await?;
+            imex(
+                &context,
+                ImexMode::ExportBackup,
+                dir.as_ref(),
+                Some(arg2.to_string()),
+            )
+            .await?;
            println!("Exported to {}.", dir.to_string_lossy());
        }
        "import-backup" => {
            ensure!(!arg1.is_empty(), "Argument <backup-file> missing.");
-            imex(&context, ImexMode::ImportBackup, arg1.as_ref()).await?;
+            imex(
+                &context,
+                ImexMode::ImportBackup,
+                arg1.as_ref(),
+                Some(arg2.to_string()),
+            )
+            .await?;
        }
        "export-keys" => {
            let dir = dirs::home_dir().unwrap_or_default();
-            imex(&context, ImexMode::ExportSelfKeys, dir.as_ref()).await?;
+            imex(&context, ImexMode::ExportSelfKeys, dir.as_ref(), None).await?;
            println!("Exported to {}.", dir.to_string_lossy());
        }
        "import-keys" => {
-            imex(&context, ImexMode::ImportSelfKeys, arg1.as_ref()).await?;
+            imex(&context, ImexMode::ImportSelfKeys, arg1.as_ref(), None).await?;
        }
        "export-setup" => {
            let setup_code = create_setup_code(&context);
--- a/python/tests/test_account.py
+++ b/python/tests/test_account.py
@@ -737,7 +737,6 @@ class TestOnlineAccount:
        # make sure we are not sending message to ourselves
        assert self_addr not in ev.data2
        assert other_addr in ev.data2
-        ev = ac1._evtracker.get_matching("DC_EVENT_DELETED_BLOB_FILE")

        lp.sec("ac1: setting bcc_self=1")
        ac1.set_config("bcc_self", "1")
@@ -753,7 +752,6 @@ class TestOnlineAccount:
        # now make sure we are sending message to ourselves too
        assert self_addr in ev.data2
        assert other_addr in ev.data2
-        ev = ac1._evtracker.get_matching("DC_EVENT_DELETED_BLOB_FILE")
        assert ac1.direct_imap.idle_wait_for_seen()

        # Second client receives only second message, but not the first
--- a/src/blob.rs
+++ b/src/blob.rs
@@ -24,6 +24,7 @@ use crate::constants::{
 };
 use crate::context::Context;
 use crate::events::EventType;
+use crate::log::LogExt;
 use crate::message;

 /// Represents a file in the blob directory.
@@ -63,7 +64,7 @@ impl<'a> BlobObject<'a> {
    ) -> std::result::Result<BlobObject<'a>, BlobError> {
        let blobdir = context.get_blobdir();
        let (stem, ext) = BlobObject::sanitise_name(suggested_name);
-        let (name, mut file) = BlobObject::create_new_file(blobdir, &stem, &ext).await?;
+        let (name, mut file) = BlobObject::create_new_file(context, blobdir, &stem, &ext).await?;
        file.write_all(data)
            .await
            .map_err(|err| BlobError::WriteFailure {
@@ -87,13 +88,16 @@ impl<'a> BlobObject<'a> {

    // Creates a new file, returning a tuple of the name and the handle.
    async fn create_new_file(
+        context: &Context,
        dir: &Path,
        stem: &str,
        ext: &str,
    ) -> Result<(String, fs::File), BlobError> {
-        let max_attempt = 15;
+        const MAX_ATTEMPT: u32 = 16;
+        let mut attempt = 0;
        let mut name = format!("{}{}", stem, ext);
-        for attempt in 0..max_attempt {
+        loop {
+            attempt += 1;
            let path = dir.join(&name);
            match fs::OpenOptions::new()
                .create_new(true)
@@ -103,24 +107,20 @@ impl<'a> BlobObject<'a> {
            {
                Ok(file) => return Ok((name, file)),
                Err(err) => {
-                    if attempt == max_attempt {
+                    if attempt >= MAX_ATTEMPT {
                        return Err(BlobError::CreateFailure {
                            blobdir: dir.to_path_buf(),
                            blobname: name,
                            cause: err,
                        });
+                    } else if attempt == 1 && !dir.exists().await {
+                        fs::create_dir_all(dir).await.ok_or_log(context);
                    } else {
                        name = format!("{}-{}{}", stem, rand::random::<u32>(), ext);
                    }
                }
            }
        }
-        // This is supposed to be unreachable, but the compiler doesn't know.
-        Err(BlobError::CreateFailure {
-            blobdir: dir.to_path_buf(),
-            blobname: name,
-            cause: std::io::Error::new(std::io::ErrorKind::Other, "supposedly unreachable"),
-        })
    }

    /// Creates a new blob object with unique name by copying an existing file.
@@ -149,7 +149,7 @@ impl<'a> BlobObject<'a> {
            })?;
        let (stem, ext) = BlobObject::sanitise_name(&src.to_string_lossy());
        let (name, mut dst_file) =
-            BlobObject::create_new_file(context.get_blobdir(), &stem, &ext).await?;
+            BlobObject::create_new_file(context, context.get_blobdir(), &stem, &ext).await?;
        let name_for_err = name.clone();
        if let Err(err) = io::copy(&mut src_file, &mut dst_file).await {
            {
--- a/src/chat.rs
+++ b/src/chat.rs
@@ -5,7 +5,7 @@ use std::convert::{TryFrom, TryInto};
 use std::str::FromStr;
 use std::time::{Duration, SystemTime};

-use anyhow::{bail, ensure, format_err, Context as _, Result};
+use anyhow::{bail, ensure, Context as _, Result};
 use async_std::path::{Path, PathBuf};
 use deltachat_derive::{FromSql, ToSql};
 use serde::{Deserialize, Serialize};
@@ -32,10 +32,14 @@ use crate::ephemeral::{delete_expired_messages, schedule_ephemeral_task, Timer a
 use crate::events::EventType;
 use crate::html::new_html_mimepart;
 use crate::job::{self, Action};
+use crate::location;
 use crate::message::{self, Message, MessageState, MsgId};
+use crate::mimefactory::MimeFactory;
 use crate::mimeparser::SystemMessage;
 use crate::param::{Param, Params};
 use crate::peerstate::{Peerstate, PeerstateVerifiedStatus};
+use crate::scheduler::InterruptInfo;
+use crate::smtp::send_msg_to_smtp;
 use crate::stock_str;
 use crate::webxdc::WEBXDC_SUFFIX;

@@ -439,6 +443,7 @@ impl ChatId {
                &msg_text,
                cmd,
                dc_create_smeared_timestamp(context).await,
+                None,
            )
            .await?;
        }
@@ -1283,7 +1288,7 @@ impl Chat {
            msg.param.set_int(Param::AttachGroupImage, 1);
            self.param.remove(Param::Unpromoted);
            self.update_param(context).await?;
-            // send_sync_msg() is called (usually) a moment later at Job::send_msg_to_smtp()
+            // send_sync_msg() is called (usually) a moment later at send_msg_to_smtp()
            // when the group-creation message is actually sent though SMTP -
            // this makes sure, the other devices are aware of grpid that is used in the sync-message.
            context.sync_qr_code_tokens(Some(self.id)).await?;
@@ -1831,25 +1836,30 @@ async fn prepare_msg_blob(context: &Context, msg: &mut Message) -> Result<()> {
            if let Some((better_type, better_mime)) =
                message::guess_msgtype_from_suffix(&blob.to_abs_path())
            {
-                msg.viewtype = better_type;
-                if !msg.param.exists(Param::MimeType) {
-                    msg.param.set(Param::MimeType, better_mime);
+                if better_type != Viewtype::Webxdc
+                    || context
+                        .ensure_sendable_webxdc_file(&blob.to_abs_path())
+                        .await
+                        .is_ok()
+                {
+                    msg.viewtype = better_type;
+                    if !msg.param.exists(Param::MimeType) {
+                        msg.param.set(Param::MimeType, better_mime);
+                    }
                }
            }
-        } else if !msg.param.exists(Param::MimeType) {
+        } else if msg.viewtype == Viewtype::Webxdc {
+            context
+                .ensure_sendable_webxdc_file(&blob.to_abs_path())
+                .await?;
+        }
+
+        if !msg.param.exists(Param::MimeType) {
            if let Some((_, mime)) = message::guess_msgtype_from_suffix(&blob.to_abs_path()) {
                msg.param.set(Param::MimeType, mime);
            }
        }

-        if msg.viewtype == Viewtype::Webxdc && blob.suffix() != Some(WEBXDC_SUFFIX) {
-            bail!(
-                "webxdc message {} does not have suffix {}",
-                blob,
-                WEBXDC_SUFFIX
-            );
-        }
-
        info!(
            context,
            "Attaching \"{}\" for message type #{}.",
@@ -1953,41 +1963,25 @@ pub async fn send_msg(context: &Context, chat_id: ChatId, msg: &mut Message) ->

 /// Tries to send a message synchronously.
 ///
-/// Directly  opens an smtp
-/// connection and sends the message, bypassing the job system. If this fails, it writes a send job to
-/// the database.
+/// Creates a new message in `smtp` table, then drectly opens an SMTP connection and sends the
+/// message. If this fails, the message remains in the database to be sent later.
 pub async fn send_msg_sync(context: &Context, chat_id: ChatId, msg: &mut Message) -> Result<MsgId> {
-    if let Some(mut job) = prepare_send_msg(context, chat_id, msg).await? {
+    if let Some(rowid) = prepare_send_msg(context, chat_id, msg).await? {
        let mut smtp = crate::smtp::Smtp::new();
+        send_msg_to_smtp(context, &mut smtp, rowid)
+            .await
+            .context("failed to send message, queued for later sending")?;

-        let status = job.send_msg_to_smtp(context, &mut smtp).await;
-
-        match status {
-            job::Status::Finished(Ok(_)) => {
-                context.emit_event(EventType::MsgsChanged {
-                    chat_id: msg.chat_id,
-                    msg_id: msg.id,
-                });
-
-                Ok(msg.id)
-            }
-            _ => {
-                job.save(context).await?;
-                Err(format_err!(
-                    "failed to send message, queued for later sending"
-                ))
-            }
-        }
-    } else {
-        // Nothing to do
-        Ok(msg.id)
+        context.emit_event(EventType::MsgsChanged {
+            chat_id: msg.chat_id,
+            msg_id: msg.id,
+        });
    }
+    Ok(msg.id)
 }

 async fn send_msg_inner(context: &Context, chat_id: ChatId, msg: &mut Message) -> Result<MsgId> {
-    if let Some(send_job) = prepare_send_msg(context, chat_id, msg).await? {
-        job::add(context, send_job).await?;
-
+    if prepare_send_msg(context, chat_id, msg).await?.is_some() {
        context.emit_event(EventType::MsgsChanged {
            chat_id: msg.chat_id,
            msg_id: msg.id,
@@ -1996,16 +1990,19 @@ async fn send_msg_inner(context: &Context, chat_id: ChatId, msg: &mut Message) -
        if msg.param.exists(Param::SetLatitude) {
            context.emit_event(EventType::LocationChanged(Some(DC_CONTACT_ID_SELF)));
        }
+
+        context.interrupt_smtp(InterruptInfo::new(false)).await;
    }

    Ok(msg.id)
 }

+/// Returns rowid from `smtp` table.
 async fn prepare_send_msg(
    context: &Context,
    chat_id: ChatId,
    msg: &mut Message,
-) -> Result<Option<crate::job::Job>> {
+) -> Result<Option<i64>> {
    // dc_prepare_msg() leaves the message state to OutPreparing, we
    // only have to change the state to OutPending in this case.
    // Otherwise we still have to prepare the message, which will set
@@ -2021,9 +2018,143 @@ async fn prepare_send_msg(
        );
        message::update_msg_state(context, msg.id, MessageState::OutPending).await?;
    }
-    let job = job::send_msg_job(context, msg.id).await?;
+    let row_id = create_send_msg_job(context, msg.id).await?;
+    Ok(row_id)
+}

-    Ok(job)
+/// Constructs a job for sending a message and inserts into `smtp` table.
+///
+/// Returns rowid if job was created or `None` if SMTP job is not needed, e.g. when sending to a
+/// group with only self and no BCC-to-self configured.
+///
+/// The caller has to interrupt SMTP loop or otherwise process a new row.
+async fn create_send_msg_job(context: &Context, msg_id: MsgId) -> Result<Option<i64>> {
+    let mut msg = Message::load_from_db(context, msg_id).await?;
+    msg.try_calc_and_set_dimensions(context)
+        .await
+        .context("failed to calculate media dimensions")?;
+
+    /* create message */
+    let needs_encryption = msg.param.get_bool(Param::GuaranteeE2ee).unwrap_or_default();
+
+    let attach_selfavatar = match shall_attach_selfavatar(context, msg.chat_id).await {
+        Ok(attach_selfavatar) => attach_selfavatar,
+        Err(err) => {
+            warn!(context, "job: cannot get selfavatar-state: {}", err);
+            false
+        }
+    };
+
+    let mimefactory = MimeFactory::from_msg(context, &msg, attach_selfavatar).await?;
+
+    let mut recipients = mimefactory.recipients();
+
+    let from = context
+        .get_config(Config::ConfiguredAddr)
+        .await?
+        .unwrap_or_default();
+    let lowercase_from = from.to_lowercase();
+
+    // Send BCC to self if it is enabled and we are not going to
+    // delete it immediately.
+    if context.get_config_bool(Config::BccSelf).await?
+        && context.get_config_delete_server_after().await? != Some(0)
+        && !recipients
+            .iter()
+            .any(|x| x.to_lowercase() == lowercase_from)
+    {
+        recipients.push(from);
+    }
+
+    if recipients.is_empty() {
+        // may happen eg. for groups with only SELF and bcc_self disabled
+        info!(
+            context,
+            "message {} has no recipient, skipping smtp-send", msg_id
+        );
+        msg_id.set_delivered(context).await?;
+        return Ok(None);
+    }
+
+    let rendered_msg = match mimefactory.render(context).await {
+        Ok(res) => Ok(res),
+        Err(err) => {
+            message::set_msg_failed(context, msg_id, Some(err.to_string())).await;
+            Err(err)
+        }
+    }?;
+
+    if needs_encryption && !rendered_msg.is_encrypted {
+        /* unrecoverable */
+        message::set_msg_failed(
+            context,
+            msg_id,
+            Some("End-to-end-encryption unavailable unexpectedly."),
+        )
+        .await;
+        bail!(
+            "e2e encryption unavailable {} - {:?}",
+            msg_id,
+            needs_encryption
+        );
+    }
+
+    if rendered_msg.is_gossiped {
+        msg.chat_id.set_gossiped_timestamp(context, time()).await?;
+    }
+
+    if 0 != rendered_msg.last_added_location_id {
+        if let Err(err) = location::set_kml_sent_timestamp(context, msg.chat_id, time()).await {
+            error!(context, "Failed to set kml sent_timestamp: {:?}", err);
+        }
+        if !msg.hidden {
+            if let Err(err) =
+                location::set_msg_location_id(context, msg.id, rendered_msg.last_added_location_id)
+                    .await
+            {
+                error!(context, "Failed to set msg_location_id: {:?}", err);
+            }
+        }
+    }
+
+    if let Some(sync_ids) = rendered_msg.sync_ids_to_delete {
+        if let Err(err) = context.delete_sync_ids(sync_ids).await {
+            error!(context, "Failed to delete sync ids: {:?}", err);
+        }
+    }
+
+    if attach_selfavatar {
+        if let Err(err) = msg.chat_id.set_selfavatar_timestamp(context, time()).await {
+            error!(context, "Failed to set selfavatar timestamp: {:?}", err);
+        }
+    }
+
+    if rendered_msg.is_encrypted && !needs_encryption {
+        msg.param.set_int(Param::GuaranteeE2ee, 1);
+        msg.update_param(context).await;
+    }
+
+    ensure!(!recipients.is_empty(), "no recipients for smtp job set");
+
+    let recipients = recipients.join(" ");
+
+    msg.subject = rendered_msg.subject.clone();
+    msg.update_subject(context).await;
+
+    let row_id = context
+        .sql
+        .insert(
+            "INSERT INTO smtp (rfc724_mid, recipients, mime, msg_id)
+             VALUES           (?1,         ?2,         ?3,   ?4)",
+            paramsv![
+                &rendered_msg.rfc724_mid,
+                recipients,
+                &rendered_msg.message,
+                msg_id
+            ],
+        )
+        .await?;
+    Ok(Some(row_id))
 }

 pub async fn send_text_msg(
@@ -3008,6 +3139,8 @@ pub async fn forward_msgs(context: &Context, msg_ids: &[MsgId], chat_id: ChatId)
            msg.param.remove(Param::ForcePlaintext);
            msg.param.remove(Param::Cmd);
            msg.param.remove(Param::OverrideSenderDisplayname);
+            msg.param.remove(Param::WebxdcSummary);
+            msg.param.remove(Param::WebxdcSummaryTimestamp);
            msg.in_reply_to = None;

            // do not leak data as group names; a default subject is generated by mimfactory
@@ -3039,8 +3172,8 @@ pub async fn forward_msgs(context: &Context, msg_ids: &[MsgId], chat_id: ChatId)
                    .prepare_msg_raw(context, &mut msg, None, curr_timestamp)
                    .await?;
                curr_timestamp += 1;
-                if let Some(send_job) = job::send_msg_job(context, new_msg_id).await? {
-                    job::add(context, send_job).await?;
+                if create_send_msg_job(context, new_msg_id).await?.is_some() {
+                    context.interrupt_smtp(InterruptInfo::new(false)).await;
                }
            }
            created_chats.push(chat_id);
@@ -3254,6 +3387,7 @@ pub(crate) async fn add_info_msg_with_cmd(
    text: &str,
    cmd: SystemMessage,
    timestamp: i64,
+    parent: Option<&Message>,
 ) -> Result<MsgId> {
    let rfc724_mid = dc_create_outgoing_rfc724_mid(None, "@device");
    let ephemeral_timer = chat_id.get_ephemeral_timer(context).await?;
@@ -3265,7 +3399,7 @@ pub(crate) async fn add_info_msg_with_cmd(

    let row_id =
    context.sql.insert(
-        "INSERT INTO msgs (chat_id,from_id,to_id,timestamp,type,state,txt,rfc724_mid,ephemeral_timer, param) VALUES (?,?,?, ?,?,?, ?,?,?, ?);",
+        "INSERT INTO msgs (chat_id,from_id,to_id,timestamp,type,state,txt,rfc724_mid,ephemeral_timer, param,mime_in_reply_to) VALUES (?,?,?, ?,?,?, ?,?,?, ?,?);",
        paramsv![
            chat_id,
            DC_CONTACT_ID_INFO,
@@ -3277,6 +3411,7 @@ pub(crate) async fn add_info_msg_with_cmd(
            rfc724_mid,
            ephemeral_timer,
            param.to_string(),
+            parent.map(|msg|msg.rfc724_mid.clone()).unwrap_or_default()
        ]
    ).await?;

@@ -3292,7 +3427,15 @@ pub(crate) async fn add_info_msg(
    text: &str,
    timestamp: i64,
 ) -> Result<MsgId> {
-    add_info_msg_with_cmd(context, chat_id, text, SystemMessage::Unknown, timestamp).await
+    add_info_msg_with_cmd(
+        context,
+        chat_id,
+        text,
+        SystemMessage::Unknown,
+        timestamp,
+        None,
+    )
+    .await
 }

 #[cfg(test)]
@@ -4278,34 +4421,37 @@ mod tests {
        assert_eq!(msg.get_text().unwrap(), "foo info");
        assert!(msg.is_info());
        assert_eq!(msg.get_info_type(), SystemMessage::Unknown);
+        assert!(msg.parent(&t).await?.is_none());
+        assert!(msg.quoted_message(&t).await?.is_none());
        Ok(())
    }

    #[async_std::test]
-    async fn test_add_info_msg_with_cmd() {
+    async fn test_add_info_msg_with_cmd() -> Result<()> {
        let t = TestContext::new().await;
-        let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "foo")
-            .await
-            .unwrap();
+        let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "foo").await?;
        let msg_id = add_info_msg_with_cmd(
            &t,
            chat_id,
            "foo bar info",
            SystemMessage::EphemeralTimerChanged,
            10000,
+            None,
        )
-        .await
-        .unwrap();
+        .await?;

-        let msg = Message::load_from_db(&t, msg_id).await.unwrap();
+        let msg = Message::load_from_db(&t, msg_id).await?;
        assert_eq!(msg.get_chat_id(), chat_id);
        assert_eq!(msg.get_viewtype(), Viewtype::Text);
        assert_eq!(msg.get_text().unwrap(), "foo bar info");
        assert!(msg.is_info());
        assert_eq!(msg.get_info_type(), SystemMessage::EphemeralTimerChanged);
+        assert!(msg.parent(&t).await?.is_none());
+        assert!(msg.quoted_message(&t).await?.is_none());

        let msg2 = t.get_last_msg_in(chat_id).await;
        assert_eq!(msg.get_id(), msg2.get_id());
+        Ok(())
    }

    #[async_std::test]
@@ -4457,7 +4603,8 @@ mod tests {
        );

        // Alice has an SMTP-server replacing the `Message-ID:`-header (as done eg. by outlook.com).
-        let msg = alice.pop_sent_msg().await.payload();
+        let sent_msg = alice.pop_sent_msg().await;
+        let msg = sent_msg.payload();
        assert_eq!(msg.match_indices("Gr.").count(), 2);
        let msg = msg.replace("Message-ID: <Gr.", "Message-ID: <XXX");
        assert_eq!(msg.match_indices("Gr.").count(), 1);
@@ -4477,7 +4624,8 @@ mod tests {
        // Bob answers - simulate a normal MUA by not setting `Chat-*`-headers;
        // moreover, Bob's SMTP-server also replaces the `Message-ID:`-header
        send_text_msg(&bob, bob_chat.id, "ho!".to_string()).await?;
-        let msg = bob.pop_sent_msg().await.payload();
+        let sent_msg = bob.pop_sent_msg().await;
+        let msg = sent_msg.payload();
        let msg = msg.replace("Message-ID: <Gr.", "Message-ID: <XXX");
        let msg = msg.replace("Chat-", "XXXX-");
        assert_eq!(msg.match_indices("Chat-").count(), 0);
--- a/src/config.rs
+++ b/src/config.rs
@@ -65,7 +65,7 @@ pub enum Config {
    #[strum(props(default = "1"))]
    MdnsEnabled,

-    #[strum(props(default = "1"))]
+    #[strum(props(default = "0"))]
    SentboxWatch,

    #[strum(props(default = "1"))]
@@ -74,6 +74,13 @@ pub enum Config {
    #[strum(props(default = "0"))]
    SentboxMove, // If `MvboxMove` is true, this config is ignored. Currently only used in tests.

+    /// Watch for new messages in the "Mvbox" (aka DeltaChat folder) only.
+    ///
+    /// This will not entirely disable other folders, e.g. the spam folder will also still
+    /// be watched for new messages.
+    #[strum(props(default = "0"))]
+    OnlyFetchMvbox,
+
    #[strum(props(default = "0"))] // also change ShowEmails.default() on changes
    ShowEmails,

@@ -225,6 +232,11 @@ impl Context {
        Ok(self.get_config_int(key).await? != 0)
    }

+    pub(crate) async fn should_watch_mvbox(&self) -> Result<bool> {
+        Ok(self.get_config_bool(Config::MvboxMove).await?
+            || self.get_config_bool(Config::OnlyFetchMvbox).await?)
+    }
+
    /// Gets configured "delete_server_after" value.
    ///
    /// `None` means never delete the message, `Some(0)` means delete
@@ -281,35 +293,29 @@ impl Context {
                    }
                }
                self.emit_event(EventType::SelfavatarChanged);
-                Ok(())
            }
            Config::DeleteDeviceAfter => {
-                let ret = self
-                    .sql
-                    .set_raw_config(key, value)
-                    .await
-                    .map_err(Into::into);
+                let ret = self.sql.set_raw_config(key, value).await;
                // Force chatlist reload to delete old messages immediately.
                self.emit_event(EventType::MsgsChanged {
                    msg_id: MsgId::new(0),
                    chat_id: ChatId::new(0),
                });
-                ret
+                ret?
            }
            Config::Displayname => {
                let value = value.map(improve_single_line_input);
                self.sql.set_raw_config(key, value.as_deref()).await?;
-                Ok(())
            }
            _ => {
                self.sql.set_raw_config(key, value).await?;
-                Ok(())
            }
        }
+        Ok(())
    }

    pub async fn set_config_bool(&self, key: Config, value: bool) -> Result<()> {
-        self.set_config(key, if value { Some("1") } else { None })
+        self.set_config(key, if value { Some("1") } else { Some("0") })
            .await?;
        Ok(())
    }
@@ -401,4 +407,17 @@ mod tests {

        Ok(())
    }
+
+    /// Regression test for https://github.com/deltachat/deltachat-core-rust/issues/3012
+    #[async_std::test]
+    async fn test_set_config_bool() -> Result<()> {
+        let t = TestContext::new().await;
+
+        // We need some config that defaults to true
+        let c = Config::E2eeEnabled;
+        assert_eq!(t.get_config_bool(c).await?, true);
+        t.set_config_bool(c, false).await?;
+        assert_eq!(t.get_config_bool(c).await?, false);
+        Ok(())
+    }
 }
--- a/src/configure.rs
+++ b/src/configure.rs
@@ -443,7 +443,7 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {

    progress!(ctx, 900);

-    let create_mvbox = ctx.get_config_bool(Config::MvboxMove).await?;
+    let create_mvbox = ctx.should_watch_mvbox().await?;

    imap.configure_folders(ctx, create_mvbox).await?;

@@ -454,11 +454,8 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {
    drop(imap);

    progress!(ctx, 910);
-    // configuration success - write back the configured parameters with the
-    // "configured_" prefix; also write the "configured"-flag */
    // the trailing underscore is correct
    param.save_to_database(ctx, "configured_").await?;
-    ctx.sql.set_raw_config_bool("configured", true).await?;
    ctx.set_config(Config::ConfiguredTimestamp, Some(&time().to_string()))
        .await?;

@@ -476,6 +473,8 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {
    progress!(ctx, 940);
    update_device_chats_handle.await?;

+    ctx.sql.set_raw_config_bool("configured", true).await?;
+
    Ok(())
 }

--- a/src/context.rs
+++ b/src/context.rs
@@ -109,8 +109,8 @@ impl Context {
        let context = Self::new_closed(dbfile, id).await?;

        // Open the database if is not encrypted.
-        if context.set_passphrase("".to_string()).await? {
-            context.sql.open(&context).await?;
+        if context.check_passphrase("".to_string()).await? {
+            context.sql.open(&context, "".to_string()).await?;
        }
        Ok(context)
    }
@@ -133,8 +133,8 @@ impl Context {
    /// Returns true if passphrase is correct, false is passphrase is not correct. Fails on other
    /// errors.
    pub async fn open(&self, passphrase: String) -> Result<bool> {
-        if self.sql.set_passphrase(passphrase).await? {
-            self.sql.open(self).await?;
+        if self.sql.check_passphrase(passphrase.clone()).await? {
+            self.sql.open(self, passphrase).await?;
            Ok(true)
        } else {
            Ok(false)
@@ -146,13 +146,13 @@ impl Context {
        self.sql.is_open().await
    }

-    /// Sets the database passphrase.
+    /// Tests the database passphrase.
    ///
    /// Returns true if passphrase is correct.
    ///
    /// Fails if database is already open.
-    pub async fn set_passphrase(&self, passphrase: String) -> Result<bool> {
-        self.sql.set_passphrase(passphrase).await
+    pub(crate) async fn check_passphrase(&self, passphrase: String) -> Result<bool> {
+        self.sql.check_passphrase(passphrase).await
    }

    pub(crate) async fn with_blobdir(
@@ -358,6 +358,7 @@ impl Context {
        let sentbox_watch = self.get_config_int(Config::SentboxWatch).await?;
        let mvbox_move = self.get_config_int(Config::MvboxMove).await?;
        let sentbox_move = self.get_config_int(Config::SentboxMove).await?;
+        let only_fetch_mvbox = self.get_config_int(Config::OnlyFetchMvbox).await?;
        let folders_configured = self
            .sql
            .get_raw_config_int("folders_configured")
@@ -383,6 +384,13 @@ impl Context {
        res.insert("number_of_contacts", contacts.to_string());
        res.insert("database_dir", self.get_dbfile().display().to_string());
        res.insert("database_version", dbversion.to_string());
+        res.insert(
+            "database_encrypted",
+            self.sql
+                .is_encrypted()
+                .await
+                .map_or_else(|| "closed".to_string(), |b| b.to_string()),
+        );
        res.insert("journal_mode", journal_mode);
        res.insert("blobdir", self.get_blobdir().display().to_string());
        res.insert("display_name", displayname.unwrap_or_else(|| unset.into()));
@@ -415,6 +423,7 @@ impl Context {
        res.insert("sentbox_watch", sentbox_watch.to_string());
        res.insert("mvbox_move", mvbox_move.to_string());
        res.insert("sentbox_move", sentbox_move.to_string());
+        res.insert("only_fetch_mvbox", only_fetch_mvbox.to_string());
        res.insert("folders_configured", folders_configured.to_string());
        res.insert("configured_sentbox_folder", configured_sentbox_folder);
        res.insert("configured_mvbox_folder", configured_mvbox_folder);
@@ -1039,7 +1048,7 @@ mod tests {
    }

    #[async_std::test]
-    async fn test_set_passphrase() -> Result<()> {
+    async fn test_check_passphrase() -> Result<()> {
        let dir = tempdir()?;
        let dbfile = dir.path().join("db.sqlite");

@@ -1056,7 +1065,7 @@ mod tests {
            .await
            .context("failed to create context")?;
        assert_eq!(context.is_open().await, false);
-        assert_eq!(context.set_passphrase("bar".to_string()).await?, false);
+        assert_eq!(context.check_passphrase("bar".to_string()).await?, false);
        assert_eq!(context.open("false".to_string()).await?, false);
        assert_eq!(context.open("foo".to_string()).await?, true);

--- a/src/dc_receive_imf.rs
+++ b/src/dc_receive_imf.rs
@@ -4866,7 +4866,7 @@ Second thread."#;
        let mdn_body = rendered_mdn.message;

        // Alice receives the read receipt.
-        dc_receive_imf(&alice, &mdn_body, "INBOX", false).await?;
+        dc_receive_imf(&alice, mdn_body.as_bytes(), "INBOX", false).await?;

        // Chat should not pop up in the chatlist.
        let chats = Chatlist::try_load(&alice, 0, None, None).await?;
--- a/src/dc_tools.rs
+++ b/src/dc_tools.rs
@@ -13,7 +13,7 @@ use async_std::path::{Path, PathBuf};
 use async_std::prelude::*;
 use async_std::{fs, io};

-use anyhow::{bail, Error};
+use anyhow::Error;
 use chrono::{Local, TimeZone};
 use mailparse::dateparse;
 use mailparse::headers::Headers;
@@ -195,44 +195,26 @@ async fn maybe_warn_on_outdated(context: &Context, now: i64, approx_compile_time
 }

 /* Message-ID tools */
+
+/// Generate an ID. The generated ID should be as short and as unique as possible:
+/// - short, because it may also used as part of Message-ID headers or in QR codes
+/// - unique as two IDs generated on two devices should not be the same. However, collisions are not world-wide but only by the few contacts.
+/// IDs generated by this function are 66 bit wide and are returned as 11 base64 characters.
+///
+/// Additional information when used as a message-id or group-id:
+/// - for OUTGOING messages this ID is written to the header as `Chat-Group-ID:` and is added to the message ID as Gr.<grpid>.<random>@<random>
+/// - for INCOMING messages, the ID is taken from the Chat-Group-ID-header or from the Message-ID in the In-Reply-To: or References:-Header
+/// - the group-id should be a string with the characters [a-zA-Z0-9\-_]
 pub(crate) fn dc_create_id() -> String {
-    /* generate an id. the generated ID should be as short and as unique as possible:
-    - short, because it may also used as part of Message-ID headers or in QR codes
-    - unique as two IDs generated on two devices should not be the same. However, collisions are not world-wide but only by the few contacts.
-    IDs generated by this function are 66 bit wide and are returned as 11 base64 characters.
-    If possible, RNG of OpenSSL is used.
-
-    Additional information when used as a message-id or group-id:
-    - for OUTGOING messages this ID is written to the header as `Chat-Group-ID:` and is added to the message ID as Gr.<grpid>.<random>@<random>
-    - for INCOMING messages, the ID is taken from the Chat-Group-ID-header or from the Message-ID in the In-Reply-To: or References:-Header
-    - the group-id should be a string with the characters [a-zA-Z0-9\-_] */
-
+    // ThreadRng implements CryptoRng trait and is supposed to be cryptographically secure.
    let mut rng = thread_rng();
-    let buf: [u32; 3] = [rng.gen(), rng.gen(), rng.gen()];

-    encode_66bits_as_base64(buf[0usize], buf[1usize], buf[2usize])
-}
+    // Generate 72 random bits.
+    let mut arr = [0u8; 9];
+    rng.fill(&mut arr[..]);

-/// Encode 66 bits as a base64 string.
-/// This is useful for ID generating with short strings as we save 5 character
-/// in each id compared to 64 bit hex encoding. For a typical group ID, these
-/// are 10 characters (grpid+msgid):
-///    hex:    64 bit, 4 bits/character, length = 64/4 = 16 characters
-///    base64: 64 bit, 6 bits/character, length = 64/6 = 11 characters (plus 2 additional bits)
-/// Only the lower 2 bits of `fill` are used.
-fn encode_66bits_as_base64(v1: u32, v2: u32, fill: u32) -> String {
-    use byteorder::{BigEndian, WriteBytesExt};
-
-    let mut wrapped_writer = Vec::new();
-    {
-        let mut enc = base64::write::EncoderWriter::new(&mut wrapped_writer, base64::URL_SAFE);
-        enc.write_u32::<BigEndian>(v1).unwrap();
-        enc.write_u32::<BigEndian>(v2).unwrap();
-        enc.write_u8(((fill & 0x3) as u8) << 6).unwrap();
-        enc.finish().unwrap();
-    }
-    assert_eq!(wrapped_writer.pop(), Some(b'A')); // Remove last "A"
-    String::from_utf8(wrapped_writer).unwrap()
+    // Take 11 base64 characters containing 66 random bits.
+    base64::encode(&arr).chars().take(11).collect()
 }

 /// Function generates a Message-ID that can be used for a new outgoing message.
@@ -451,33 +433,6 @@ pub fn dc_open_file_std<P: AsRef<std::path::Path>>(
    }
 }

-/// Returns Ok((temp_path, dest_path)) on success. The backup can then be written to temp_path. If the backup succeeded,
-/// it can be renamed to dest_path. This guarantees that the backup is complete.
-pub(crate) async fn get_next_backup_path(
-    folder: impl AsRef<Path>,
-    backup_time: i64,
-) -> Result<(PathBuf, PathBuf), Error> {
-    let folder = PathBuf::from(folder.as_ref());
-    let stem = chrono::NaiveDateTime::from_timestamp(backup_time, 0)
-        // Don't change this file name format, in has_backup() we use string comparison to determine which backup is newer:
-        .format("delta-chat-backup-%Y-%m-%d")
-        .to_string();
-
-    // 64 backup files per day should be enough for everyone
-    for i in 0..64 {
-        let mut tempfile = folder.clone();
-        tempfile.push(format!("{}-{:02}.tar.part", stem, i));
-
-        let mut destfile = folder.clone();
-        destfile.push(format!("{}-{:02}.tar", stem, i));
-
-        if !tempfile.exists().await && !destfile.exists().await {
-            return Ok((tempfile, destfile));
-        }
-    }
-    bail!("could not create backup file, disk full?");
-}
-
 pub(crate) fn time() -> i64 {
    SystemTime::now()
        .duration_since(SystemTime::UNIX_EPOCH)
@@ -807,26 +762,6 @@ Hop: From: hq5.example.org; By: hq5.example.org; Date: Mon, 27 Dec 2021 11:21:22
        assert_eq!(buf.len(), 11);
    }

-    #[test]
-    fn test_encode_66bits_as_base64() {
-        assert_eq!(
-            encode_66bits_as_base64(0x01234567, 0x89abcdef, 0),
-            "ASNFZ4mrze8"
-        );
-        assert_eq!(
-            encode_66bits_as_base64(0x01234567, 0x89abcdef, 1),
-            "ASNFZ4mrze9"
-        );
-        assert_eq!(
-            encode_66bits_as_base64(0x01234567, 0x89abcdef, 2),
-            "ASNFZ4mrze-"
-        );
-        assert_eq!(
-            encode_66bits_as_base64(0x01234567, 0x89abcdef, 3),
-            "ASNFZ4mrze_"
-        );
-    }
-
    #[test]
    fn test_dc_extract_grpid_from_rfc724_mid() {
        // Should return None if we pass invalid mid
--- a/src/imap.rs
+++ b/src/imap.rs
@@ -28,7 +28,6 @@ use crate::context::Context;
 use crate::dc_receive_imf::{
    dc_receive_imf_inner, from_field_to_contact_id, get_prefetch_parent_message, ReceivedMsg,
 };
-use crate::ephemeral::delete_expired_imap_messages;
 use crate::events::EventType;
 use crate::headerdef::{HeaderDef, HeaderDefMap};
 use crate::job::{self, Action};
@@ -459,18 +458,12 @@ impl Imap {
            .await
            .context("fetch_new_messages")?;

-        // Mark expired messages for deletion.
-        delete_expired_imap_messages(context).await?;
-
        self.move_messages(context, watch_folder)
            .await
            .context("move_messages")?;
        self.delete_messages(context, watch_folder)
            .await
            .context("delete_messages")?;
-        self.sync_seen_flags(context, watch_folder)
-            .await
-            .context("sync_seen_flags")?;

        Ok(())
    }
@@ -671,6 +664,11 @@ impl Imap {
        folder: &str,
        fetch_existing_msgs: bool,
    ) -> Result<bool> {
+        if should_ignore_folder(context, folder).await? {
+            info!(context, "Not fetching from {}", folder);
+            return Ok(false);
+        }
+
        let new_emails = self.select_with_uidvalidity(context, folder).await?;

        if !new_emails && !fetch_existing_msgs {
@@ -1013,7 +1011,9 @@ impl Imap {
            return Ok(());
        }

-        self.select_folder(context, Some(folder)).await?;
+        self.select_folder(context, Some(folder))
+            .await
+            .context("failed to select folder")?;
        let session = self
            .session
            .as_mut()
@@ -1036,66 +1036,49 @@ impl Imap {
        }

        let mut updated_chat_ids = BTreeSet::new();
-        let uid_validity = get_uidvalidity(context, folder).await?;
-        let mut highest_modseq = get_modseq(context, folder).await?;
+        let uid_validity = get_uidvalidity(context, folder)
+            .await
+            .with_context(|| format!("failed to get UID validity for folder {}", folder))?;
+        let mut highest_modseq = get_modseq(context, folder)
+            .await
+            .with_context(|| format!("failed to get MODSEQ for folder {}", folder))?;
        let mut list = session
            .uid_fetch("1:*", format!("(FLAGS) (CHANGEDSINCE {})", highest_modseq))
            .await
            .context("failed to fetch flags")?;

        while let Some(fetch) = list.next().await {
-            let msg = fetch?;
-
-            let is_seen = msg.flags().any(|flag| flag == Flag::Seen);
+            let fetch = fetch.context("failed to get FETCH result")?;
+            let uid = if let Some(uid) = fetch.uid {
+                uid
+            } else {
+                info!(context, "FETCH result contains no UID, skipping");
+                continue;
+            };
+            let is_seen = fetch.flags().any(|flag| flag == Flag::Seen);
            if is_seen {
-                if let Some((msg_id, chat_id)) = context
-                    .sql
-                    .query_row_optional(
-                        "SELECT id, chat_id FROM msgs
-                         WHERE rfc724_mid IN (
-                           SELECT rfc724_mid FROM imap
-                           WHERE folder=?1
-                           AND uidvalidity=?2
-                           AND uid=?3
-                           LIMIT 1
-                         )",
-                        paramsv![&folder, uid_validity, msg.uid],
-                        |row| {
-                            let msg_id: MsgId = row.get(0)?;
-                            let chat_id: ChatId = row.get(1)?;
-                            Ok((msg_id, chat_id))
-                        },
-                    )
-                    .await?
+                if let Some(chat_id) = mark_seen_by_uid(context, folder, uid_validity, uid)
+                    .await
+                    .with_context(|| {
+                        format!("failed to update seen status for msg {}/{}", folder, uid)
+                    })?
                {
-                    let updated = context
-                        .sql
-                        .execute(
-                            "UPDATE msgs SET state=?1
-                             WHERE (state=?2 OR state=?3)
-                             AND id=?4",
-                            paramsv![
-                                MessageState::InSeen,
-                                MessageState::InFresh,
-                                MessageState::InNoticed,
-                                msg_id
-                            ],
-                        )
-                        .await?
-                        > 0;
-
-                    if updated {
-                        updated_chat_ids.insert(chat_id);
-                        let modseq = msg.modseq.unwrap_or_default();
-                        if modseq > highest_modseq {
-                            highest_modseq = modseq;
-                        }
-                    }
+                    updated_chat_ids.insert(chat_id);
                }
            }
+
+            if let Some(modseq) = fetch.modseq {
+                if modseq > highest_modseq {
+                    highest_modseq = modseq;
+                }
+            } else {
+                warn!(context, "FETCH result contains no MODSEQ");
+            }
        }

-        set_modseq(context, folder, highest_modseq).await?;
+        set_modseq(context, folder, highest_modseq)
+            .await
+            .with_context(|| format!("failed to set MODSEQ for folder {}", folder))?;
        for updated_chat_id in updated_chat_ids {
            context.emit_event(EventType::MsgsNoticed(updated_chat_id));
        }
@@ -1658,7 +1641,11 @@ async fn spam_target_folder(
        }
    }

-    if needs_move_to_mvbox(context, headers).await? {
+    if needs_move_to_mvbox(context, headers).await?
+        // We don't want to move the message to the inbox or sentbox where we wouldn't
+        // fetch it again:
+        || context.get_config_bool(Config::OnlyFetchMvbox).await?
+    {
        Ok(Some(Config::ConfiguredMvboxFolder))
    } else if needs_move_to_sentbox(context, folder, headers).await? {
        Ok(Some(Config::ConfiguredSentboxFolder))
@@ -1980,6 +1967,70 @@ fn get_fallback_folder(delimiter: &str) -> String {
    format!("INBOX{}DeltaChat", delimiter)
 }

+/// Marks messages in `msgs` table as seen, searching for them by UID.
+///
+/// Returns updated chat ID if any message was marked as seen.
+async fn mark_seen_by_uid(
+    context: &Context,
+    folder: &str,
+    uid_validity: u32,
+    uid: u32,
+) -> Result<Option<ChatId>> {
+    if let Some((msg_id, chat_id)) = context
+        .sql
+        .query_row_optional(
+            "SELECT id, chat_id FROM msgs
+                 WHERE rfc724_mid IN (
+                   SELECT rfc724_mid FROM imap
+                   WHERE folder=?1
+                   AND uidvalidity=?2
+                   AND uid=?3
+                   LIMIT 1
+                 )",
+            paramsv![&folder, uid_validity, uid],
+            |row| {
+                let msg_id: MsgId = row.get(0)?;
+                let chat_id: ChatId = row.get(1)?;
+                Ok((msg_id, chat_id))
+            },
+        )
+        .await
+        .with_context(|| {
+            format!(
+                "failed to get msg and chat ID for IMAP message {}/{}",
+                folder, uid
+            )
+        })?
+    {
+        let updated = context
+            .sql
+            .execute(
+                "UPDATE msgs SET state=?1
+                     WHERE (state=?2 OR state=?3)
+                     AND id=?4",
+                paramsv![
+                    MessageState::InSeen,
+                    MessageState::InFresh,
+                    MessageState::InNoticed,
+                    msg_id
+                ],
+            )
+            .await
+            .with_context(|| format!("failed to update msg {} state", msg_id))?
+            > 0;
+
+        if updated {
+            Ok(Some(chat_id))
+        } else {
+            // Message state has not chnaged.
+            Ok(None)
+        }
+    } else {
+        // There is no message is `msgs` table matchng the given UID.
+        Ok(None)
+    }
+}
+
 /// uid_next is the next unique identifier value from the last time we fetched a folder
 /// See <https://tools.ietf.org/html/rfc3501#section-2.3.1.1>
 /// This function is used to update our uid_next after fetching messages.
@@ -2076,6 +2127,21 @@ pub async fn get_config_last_seen_uid(context: &Context, folder: &str) -> Result
    }
 }

+/// Whether to ignore fetching messages from a folder.
+///
+/// This caters for the [`Config::OnlyFetchMvbox`] setting which means mails from folders
+/// not explicitly watched should not be fetched.
+async fn should_ignore_folder(context: &Context, folder: &str) -> Result<bool> {
+    if !context.get_config_bool(Config::OnlyFetchMvbox).await? {
+        return Ok(false);
+    }
+    if context.is_sentbox(folder).await? {
+        // Still respect the SentboxWatch setting.
+        return Ok(!context.get_config_bool(Config::SentboxWatch).await?);
+    }
+    Ok(!(context.is_mvbox(folder).await? || context.is_spam_folder(folder).await?))
+}
+
 /// Builds a list of sequence/uid sets. The returned sets have each no more than around 1000
 /// characters because according to <https://tools.ietf.org/html/rfc2683#section-3.2.1.5>
 /// command lines should not be much more than 1000 chars (servers should allow at least 8000 chars)
--- a/src/imap/idle.rs
+++ b/src/imap/idle.rs
@@ -157,7 +157,6 @@ impl Imap {
                    // in anything.  If so, we behave as if IDLE had data but
                    // will have already fetched the messages so perform_*_fetch
                    // will not find any new.
-
                    match self.fetch_new_messages(context, &watch_folder, false).await {
                        Ok(res) => {
                            info!(context, "fetch_new_messages returned {:?}", res);
--- a/src/imap/scan_folders.rs
+++ b/src/imap/scan_folders.rs
@@ -10,7 +10,8 @@ use async_std::prelude::*;
 use super::{get_folder_meaning, get_folder_meaning_by_name};

 impl Imap {
-    pub(crate) async fn scan_folders(&mut self, context: &Context) -> Result<()> {
+    /// Returns true if folders were scanned, false if scanning was postponed.
+    pub(crate) async fn scan_folders(&mut self, context: &Context) -> Result<bool> {
        // First of all, debounce to once per minute:
        let mut last_scan = context.last_full_folder_scan.lock().await;
        if let Some(last_scan) = *last_scan {
@@ -20,7 +21,7 @@ impl Imap {
                .await?;

            if elapsed_secs < debounce_secs {
-                return Ok(());
+                return Ok(false);
            }
        }
        info!(context, "Starting full folder scan");
@@ -98,24 +99,26 @@ impl Imap {
        }

        last_scan.replace(Instant::now());
-        Ok(())
+        Ok(true)
    }
 }

+pub(crate) async fn get_watched_folder_configs(context: &Context) -> Result<Vec<Config>> {
+    let mut res = vec![Config::ConfiguredInboxFolder];
+    if context.get_config_bool(Config::SentboxWatch).await? {
+        res.push(Config::ConfiguredSentboxFolder);
+    }
+    if context.should_watch_mvbox().await? {
+        res.push(Config::ConfiguredMvboxFolder);
+    }
+    Ok(res)
+}
+
 pub(crate) async fn get_watched_folders(context: &Context) -> Result<Vec<String>> {
    let mut res = Vec::new();
-    if let Some(inbox_folder) = context.get_config(Config::ConfiguredInboxFolder).await? {
-        res.push(inbox_folder);
-    }
-    let folder_watched_configured = &[
-        (Config::SentboxWatch, Config::ConfiguredSentboxFolder),
-        (Config::MvboxMove, Config::ConfiguredMvboxFolder),
-    ];
-    for (watched, configured) in folder_watched_configured {
-        if context.get_config_bool(*watched).await? {
-            if let Some(folder) = context.get_config(*configured).await? {
-                res.push(folder);
-            }
+    for folder_config in get_watched_folder_configs(context).await? {
+        if let Some(folder) = context.get_config(folder_config).await? {
+            res.push(folder);
        }
    }
    Ok(res)
--- a/src/imex.rs
+++ b/src/imex.rs
@@ -20,7 +20,7 @@ use crate::constants::{Viewtype, DC_CONTACT_ID_SELF};
 use crate::context::Context;
 use crate::dc_tools::{
    dc_create_folder, dc_delete_file, dc_delete_files_in_dir, dc_get_filesuffix_lc,
-    dc_open_file_std, dc_read_file, dc_write_file, get_next_backup_path, time, EmailAddress,
+    dc_open_file_std, dc_read_file, dc_write_file, time, EmailAddress,
 };
 use crate::e2ee;
 use crate::events::EventType;
@@ -41,24 +41,24 @@ const BLOBS_BACKUP_NAME: &str = "blobs_backup";
 #[repr(u32)]
 pub enum ImexMode {
    /// Export all private keys and all public keys of the user to the
-    /// directory given as `param1`.  The default key is written to the files `public-key-default.asc`
+    /// directory given as `path`.  The default key is written to the files `public-key-default.asc`
    /// and `private-key-default.asc`, if there are more keys, they are written to files as
    /// `public-key-<id>.asc` and `private-key-<id>.asc`
    ExportSelfKeys = 1,

-    /// Import private keys found in the directory given as `param1`.
+    /// Import private keys found in the directory given as `path`.
    /// The last imported key is made the default keys unless its name contains the string `legacy`.
    /// Public keys are not imported.
    ImportSelfKeys = 2,

-    /// Export a backup to the directory given as `param1`.
+    /// Export a backup to the directory given as `path` with the given `passphrase`.
    /// The backup contains all contacts, chats, images and other data and device independent settings.
    /// The backup does not contain device dependent settings as ringtones or LED notification settings.
    /// The name of the backup is typically `delta-chat-<day>.tar`, if more than one backup is create on a day,
    /// the format is `delta-chat-<day>-<number>.tar`
    ExportBackup = 11,

-    /// `param1` is the file (not: directory) to import. The file is normally
+    /// `path` is the file (not: directory) to import. The file is normally
    /// created by DC_IMEX_EXPORT_BACKUP and detected by dc_imex_has_backup(). Importing a backup
    /// is only possible as long as the context is not configured or used in another way.
    ImportBackup = 12,
@@ -78,11 +78,16 @@ pub enum ImexMode {
 ///
 /// Only one import-/export-progress can run at the same time.
 /// To cancel an import-/export-progress, drop the future returned by this function.
-pub async fn imex(context: &Context, what: ImexMode, param1: &Path) -> Result<()> {
+pub async fn imex(
+    context: &Context,
+    what: ImexMode,
+    path: &Path,
+    passphrase: Option<String>,
+) -> Result<()> {
    let cancel = context.alloc_ongoing().await?;

    let res = async {
-        let success = imex_inner(context, what, param1).await;
+        let success = imex_inner(context, what, path, passphrase).await;
        match success {
            Ok(()) => {
                info!(context, "IMEX successfully completed");
@@ -115,11 +120,6 @@ async fn cleanup_aborted_imex(context: &Context, what: ImexMode) {
        dc_delete_file(context, context.get_dbfile()).await;
        dc_delete_files_in_dir(context, context.get_blobdir()).await;
    }
-    if what == ImexMode::ExportBackup || what == ImexMode::ImportBackup {
-        if let Err(e) = context.sql.open(context).await {
-            warn!(context, "Re-opening db after imex failed: {}", e);
-        }
-    }
 }

 /// Returns the filename of the backup found (otherwise an error)
@@ -396,7 +396,12 @@ fn normalize_setup_code(s: &str) -> String {
    out
 }

-async fn imex_inner(context: &Context, what: ImexMode, path: &Path) -> Result<()> {
+async fn imex_inner(
+    context: &Context,
+    what: ImexMode,
+    path: &Path,
+    passphrase: Option<String>,
+) -> Result<()> {
    info!(context, "Import/export dir: {}", path.display());
    ensure!(context.sql.is_open().await, "Database not opened.");
    context.emit_event(EventType::ImexProgress(10));
@@ -414,13 +419,27 @@ async fn imex_inner(context: &Context, what: ImexMode, path: &Path) -> Result<()
        ImexMode::ExportSelfKeys => export_self_keys(context, path).await,
        ImexMode::ImportSelfKeys => import_self_keys(context, path).await,

-        ImexMode::ExportBackup => export_backup(context, path).await,
-        ImexMode::ImportBackup => import_backup(context, path).await,
+        ImexMode::ExportBackup => {
+            export_backup(context, path, passphrase.unwrap_or_default()).await
+        }
+        ImexMode::ImportBackup => {
+            import_backup(context, path, passphrase.unwrap_or_default()).await?;
+            context.sql.run_migrations(context).await
+        }
    }
 }

-/// Import Backup
-async fn import_backup(context: &Context, backup_to_import: &Path) -> Result<()> {
+/// Imports backup into the currently open database.
+///
+/// The contents of the currently open database will be lost.
+///
+/// `passphrase` is the passphrase used to open backup database. If backup is unencrypted, pass
+/// empty string here.
+async fn import_backup(
+    context: &Context,
+    backup_to_import: &Path,
+    passphrase: String,
+) -> Result<()> {
    info!(
        context,
        "Import \"{}\" to \"{}\".",
@@ -436,12 +455,6 @@ async fn import_backup(context: &Context, backup_to_import: &Path) -> Result<()>
        !context.scheduler.read().await.is_running(),
        "cannot import backup, IO already running"
    );
-    context.sql.close().await;
-    dc_delete_file(context, context.get_dbfile()).await;
-    ensure!(
-        !context.get_dbfile().exists().await,
-        "Cannot delete old database."
-    );

    let backup_file = File::open(backup_to_import).await?;
    let file_size = backup_file.metadata().await?.len();
@@ -463,11 +476,15 @@ async fn import_backup(context: &Context, backup_to_import: &Path) -> Result<()>
        if f.path()?.file_name() == Some(OsStr::new(DBFILE_BACKUP_NAME)) {
            // async_tar can't unpack to a specified file name, so we just unpack to the blobdir and then move the unpacked file.
            f.unpack_in(context.get_blobdir()).await?;
-            fs::rename(
-                context.get_blobdir().join(DBFILE_BACKUP_NAME),
-                context.get_dbfile(),
-            )
-            .await?;
+            let unpacked_database = context.get_blobdir().join(DBFILE_BACKUP_NAME);
+            context
+                .sql
+                .import(&unpacked_database, passphrase.clone())
+                .await
+                .context("cannot import unpacked database")?;
+            fs::remove_file(unpacked_database)
+                .await
+                .context("cannot remove unpacked database")?;
        } else {
            // async_tar will unpack to blobdir/BLOBS_BACKUP_NAME, so we move the file afterwards.
            f.unpack_in(context.get_blobdir()).await?;
@@ -482,12 +499,6 @@ async fn import_backup(context: &Context, backup_to_import: &Path) -> Result<()>
        }
    }

-    context
-        .sql
-        .open(context)
-        .await
-        .context("Could not re-open db")?;
-
    delete_and_reset_all_device_msgs(context).await?;

    Ok(())
@@ -496,12 +507,44 @@ async fn import_backup(context: &Context, backup_to_import: &Path) -> Result<()>
 /*******************************************************************************
 * Export backup
 ******************************************************************************/
-#[allow(unused)]
-async fn export_backup(context: &Context, dir: &Path) -> Result<()> {
+
+/// Returns Ok((temp_db_path, temp_path, dest_path)) on success. Unencrypted database can be
+/// written to temp_db_path. The backup can then be written to temp_path. If the backup succeeded,
+/// it can be renamed to dest_path. This guarantees that the backup is complete.
+async fn get_next_backup_path(
+    folder: &Path,
+    backup_time: i64,
+) -> Result<(PathBuf, PathBuf, PathBuf)> {
+    let folder = PathBuf::from(folder);
+    let stem = chrono::NaiveDateTime::from_timestamp(backup_time, 0)
+        // Don't change this file name format, in has_backup() we use string comparison to determine which backup is newer:
+        .format("delta-chat-backup-%Y-%m-%d")
+        .to_string();
+
+    // 64 backup files per day should be enough for everyone
+    for i in 0..64 {
+        let mut tempdbfile = folder.clone();
+        tempdbfile.push(format!("{}-{:02}.db", stem, i));
+
+        let mut tempfile = folder.clone();
+        tempfile.push(format!("{}-{:02}.tar.part", stem, i));
+
+        let mut destfile = folder.clone();
+        destfile.push(format!("{}-{:02}.tar", stem, i));
+
+        if !tempdbfile.exists().await && !tempfile.exists().await && !destfile.exists().await {
+            return Ok((tempdbfile, tempfile, destfile));
+        }
+    }
+    bail!("could not create backup file, disk full?");
+}
+
+async fn export_backup(context: &Context, dir: &Path, passphrase: String) -> Result<()> {
    // get a fine backup file name (the name includes the date so that multiple backup instances are possible)
    let now = time();
-    let (temp_path, dest_path) = get_next_backup_path(dir, now).await?;
-    let _d = DeleteOnDrop(temp_path.clone());
+    let (temp_db_path, temp_path, dest_path) = get_next_backup_path(dir, now).await?;
+    let _d1 = DeleteOnDrop(temp_db_path.clone());
+    let _d2 = DeleteOnDrop(temp_path.clone());

    context
        .sql
@@ -513,16 +556,14 @@ async fn export_backup(context: &Context, dir: &Path) -> Result<()> {
        .sql
        .execute("VACUUM;", paramsv![])
        .await
-        .map_err(|e| warn!(context, "Vacuum failed, exporting anyway {}", e));
+        .map_err(|e| warn!(context, "Vacuum failed, exporting anyway {}", e))
+        .ok();

    ensure!(
        !context.scheduler.read().await.is_running(),
        "cannot export backup, IO already running"
    );

-    // we close the database during the export
-    context.sql.close().await;
-
    info!(
        context,
        "Backup '{}' to '{}'.",
@@ -530,10 +571,13 @@ async fn export_backup(context: &Context, dir: &Path) -> Result<()> {
        dest_path.display(),
    );

-    let res = export_backup_inner(context, &temp_path).await;
+    context
+        .sql
+        .export(&temp_db_path, passphrase)
+        .await
+        .with_context(|| format!("failed to backup plaintext database to {:?}", temp_db_path))?;

-    // we re-open the database after export is finished
-    context.sql.open(context).await;
+    let res = export_backup_inner(context, &temp_db_path, &temp_path).await;

    match &res {
        Ok(_) => {
@@ -552,18 +596,21 @@ impl Drop for DeleteOnDrop {
    fn drop(&mut self) {
        let file = self.0.clone();
        // Not using dc_delete_file() here because it would send a DeletedBlobFile event
-        async_std::task::block_on(async move { fs::remove_file(file).await.ok() });
+        async_std::task::block_on(fs::remove_file(file)).ok();
    }
 }

-async fn export_backup_inner(context: &Context, temp_path: &PathBuf) -> Result<()> {
+async fn export_backup_inner(
+    context: &Context,
+    temp_db_path: &Path,
+    temp_path: &Path,
+) -> Result<()> {
    let file = File::create(temp_path).await?;

    let mut builder = async_tar::Builder::new(file);

-    // append_path_with_name() wants the source path as the first argument, append_dir_all() wants it as the second argument.
    builder
-        .append_path_with_name(context.get_dbfile(), DBFILE_BACKUP_NAME)
+        .append_path_with_name(temp_db_path, DBFILE_BACKUP_NAME)
        .await?;

    let read_dir: Vec<_> = fs::read_dir(context.get_blobdir()).await?.collect().await;
@@ -842,12 +889,12 @@ mod tests {
    async fn test_export_and_import_key() {
        let context = TestContext::new_alice().await;
        let blobdir = context.ctx.get_blobdir();
-        if let Err(err) = imex(&context.ctx, ImexMode::ExportSelfKeys, blobdir).await {
+        if let Err(err) = imex(&context.ctx, ImexMode::ExportSelfKeys, blobdir, None).await {
            panic!("got error on export: {:?}", err);
        }

        let context2 = TestContext::new_alice().await;
-        if let Err(err) = imex(&context2.ctx, ImexMode::ImportSelfKeys, blobdir).await {
+        if let Err(err) = imex(&context2.ctx, ImexMode::ImportSelfKeys, blobdir, None).await {
            panic!("got error on import: {:?}", err);
        }
    }
--- a/src/job.rs
+++ b/src/job.rs
@@ -3,28 +3,24 @@
 //! This module implements a job queue maintained in the SQLite database
 //! and job types.
 use std::fmt;
-use std::future::Future;

-use anyhow::{bail, ensure, format_err, Context as _, Error, Result};
-use async_smtp::smtp::response::{Category, Code, Detail};
+use anyhow::{bail, format_err, Context as _, Error, Result};
 use deltachat_derive::{FromSql, ToSql};
 use rand::{thread_rng, Rng};

-use crate::blob::BlobObject;
-use crate::chat::{self, ChatId};
 use crate::config::Config;
 use crate::contact::{normalize_name, Contact, Modifier, Origin};
 use crate::context::Context;
-use crate::dc_tools::{dc_delete_file, dc_read_file, time};
+use crate::dc_tools::time;
 use crate::events::EventType;
 use crate::imap::{Imap, ImapActionResult};
 use crate::location;
 use crate::log::LogExt;
-use crate::message::{self, Message, MessageState, MsgId};
+use crate::message::{Message, MsgId};
 use crate::mimefactory::MimeFactory;
 use crate::param::{Param, Params};
 use crate::scheduler::InterruptInfo;
-use crate::smtp::Smtp;
+use crate::smtp::{smtp_send, Smtp};
 use crate::sql;

 // results in ~3 weeks for the last backoff timespan
@@ -109,7 +105,6 @@ pub enum Action {
    MaybeSendLocations = 5005, // low priority ...
    MaybeSendLocationsEnded = 5007,
    SendMdn = 5010,
-    SendMsgToSmtp = 5901, // ... high priority
 }

 impl Default for Action {
@@ -135,7 +130,6 @@ impl From<Action> for Thread {
            MaybeSendLocations => Thread::Smtp,
            MaybeSendLocationsEnded => Thread::Smtp,
            SendMdn => Thread::Smtp,
-            SendMsgToSmtp => Thread::Smtp,
        }
    }
 }
@@ -226,217 +220,6 @@ impl Job {
        Ok(())
    }

-    async fn smtp_send<F, Fut>(
-        &mut self,
-        context: &Context,
-        recipients: Vec<async_smtp::EmailAddress>,
-        message: Vec<u8>,
-        job_id: u32,
-        smtp: &mut Smtp,
-        success_cb: F,
-    ) -> Status
-    where
-        F: FnOnce() -> Fut,
-        Fut: Future<Output = Result<()>>,
-    {
-        // hold the smtp lock during sending of a job and
-        // its ok/error response processing. Note that if a message
-        // was sent we need to mark it in the database ASAP as we
-        // otherwise might send it twice.
-        if std::env::var(crate::DCC_MIME_DEBUG).is_ok() {
-            info!(context, "smtp-sending out mime message:");
-            println!("{}", String::from_utf8_lossy(&message));
-        }
-
-        smtp.connectivity.set_working(context).await;
-
-        let send_result = smtp.send(context, recipients, message, job_id).await;
-        smtp.last_send_error = send_result.as_ref().err().map(|e| e.to_string());
-
-        let status = match send_result {
-            Err(crate::smtp::send::Error::SmtpSend(err)) => {
-                // Remote error, retry later.
-                warn!(context, "SMTP failed to send: {:?}", &err);
-
-                let res = match err {
-                    async_smtp::smtp::error::Error::Permanent(ref response) => {
-                        // Workaround for incorrectly configured servers returning permanent errors
-                        // instead of temporary ones.
-                        let maybe_transient = match response.code {
-                            // Sometimes servers send a permanent error when actually it is a temporary error
-                            // For documentation see <https://tools.ietf.org/html/rfc3463>
-                            Code {
-                                category: Category::MailSystem,
-                                detail: Detail::Zero,
-                                ..
-                            } => {
-                                // Ignore status code 5.5.0, see <https://support.delta.chat/t/every-other-message-gets-stuck/877/2>
-                                // Maybe incorrectly configured Postfix milter with "reject" instead of "tempfail", which returns
-                                // "550 5.5.0 Service unavailable" instead of "451 4.7.1 Service unavailable - try again later".
-                                //
-                                // Other enhanced status codes, such as Postfix
-                                // "550 5.1.1 <foobar@example.org>: Recipient address rejected: User unknown in local recipient table"
-                                // are not ignored.
-                                response.first_word() == Some(&"5.5.0".to_string())
-                            }
-                            _ => false,
-                        };
-
-                        if maybe_transient {
-                            Status::RetryLater
-                        } else {
-                            // If we do not retry, add an info message to the chat.
-                            // Yandex error "554 5.7.1 [2] Message rejected under suspicion of SPAM; https://ya.cc/..."
-                            // should definitely go here, because user has to open the link to
-                            // resume message sending.
-                            Status::Finished(Err(format_err!("Permanent SMTP error: {}", err)))
-                        }
-                    }
-                    async_smtp::smtp::error::Error::Transient(ref response) => {
-                        // We got a transient 4xx response from SMTP server.
-                        // Give some time until the server-side error maybe goes away.
-
-                        if let Some(first_word) = response.first_word() {
-                            if first_word.ends_with(".1.1")
-                                || first_word.ends_with(".1.2")
-                                || first_word.ends_with(".1.3")
-                            {
-                                // Sometimes we receive transient errors that should be permanent.
-                                // Any extended smtp status codes like x.1.1, x.1.2 or x.1.3 that we
-                                // receive as a transient error are misconfigurations of the smtp server.
-                                // See <https://tools.ietf.org/html/rfc3463#section-3.2>
-                                info!(context, "Smtp-job #{} Received extended status code {} for a transient error. This looks like a misconfigured smtp server, let's fail immediatly", self.job_id, first_word);
-                                Status::Finished(Err(format_err!("Permanent SMTP error: {}", err)))
-                            } else {
-                                Status::RetryLater
-                            }
-                        } else {
-                            Status::RetryLater
-                        }
-                    }
-                    _ => {
-                        if smtp.has_maybe_stale_connection().await {
-                            info!(context, "stale connection? immediately reconnecting");
-                            Status::RetryNow
-                        } else {
-                            Status::RetryLater
-                        }
-                    }
-                };
-
-                // this clears last_success info
-                smtp.disconnect().await;
-
-                res
-            }
-            Err(crate::smtp::send::Error::Envelope(err)) => {
-                // Local error, job is invalid, do not retry.
-                smtp.disconnect().await;
-                warn!(context, "SMTP job is invalid: {}", err);
-                Status::Finished(Err(err.into()))
-            }
-            Err(crate::smtp::send::Error::NoTransport) => {
-                // Should never happen.
-                // It does not even make sense to disconnect here.
-                error!(context, "SMTP job failed because SMTP has no transport");
-                Status::Finished(Err(format_err!("SMTP has not transport")))
-            }
-            Err(crate::smtp::send::Error::Other(err)) => {
-                // Local error, job is invalid, do not retry.
-                smtp.disconnect().await;
-                warn!(context, "unable to load job: {}", err);
-                Status::Finished(Err(err))
-            }
-            Ok(()) => {
-                job_try!(success_cb().await);
-                Status::Finished(Ok(()))
-            }
-        };
-
-        if let Status::Finished(Err(err)) = &status {
-            // We couldn't send the message, so mark it as failed
-            let msg_id = MsgId::new(self.foreign_id);
-            message::set_msg_failed(context, msg_id, Some(err.to_string())).await;
-        }
-        status
-    }
-
-    pub(crate) async fn send_msg_to_smtp(&mut self, context: &Context, smtp: &mut Smtp) -> Status {
-        //  SMTP server, if not yet done
-        if let Err(err) = smtp.connect_configured(context).await {
-            warn!(context, "SMTP connection failure: {:?}", err);
-            smtp.last_send_error = Some(format!("SMTP connection failure: {:#}", err));
-            return Status::RetryLater;
-        }
-
-        let filename = job_try!(job_try!(self
-            .param
-            .get_path(Param::File, context)
-            .context("can't get filename"))
-        .context("Can't get filename"));
-        let body = job_try!(dc_read_file(context, &filename).await);
-        let recipients = job_try!(self
-            .param
-            .get(Param::Recipients)
-            .context("missing recipients"));
-
-        let recipients_list = recipients
-            .split('\x1e')
-            .filter_map(
-                |addr| match async_smtp::EmailAddress::new(addr.to_string()) {
-                    Ok(addr) => Some(addr),
-                    Err(err) => {
-                        warn!(context, "invalid recipient: {} {:?}", addr, err);
-                        None
-                    }
-                },
-            )
-            .collect::<Vec<_>>();
-
-        /* if there is a msg-id and it does not exist in the db, cancel sending.
-        this happends if dc_delete_msgs() was called
-        before the generated mime was sent out */
-        if 0 != self.foreign_id {
-            match message::exists(context, MsgId::new(self.foreign_id)).await {
-                Ok(exists) => {
-                    if !exists {
-                        return Status::Finished(Err(format_err!(
-                            "Not sending Message {} as it was deleted",
-                            self.foreign_id
-                        )));
-                    }
-                }
-                Err(err) => {
-                    warn!(context, "failed to check message existence: {:?}", err);
-                    smtp.last_send_error =
-                        Some(format!("failed to check message existence: {:#}", err));
-                    return Status::RetryLater;
-                }
-            }
-        };
-
-        let foreign_id = self.foreign_id;
-        self.smtp_send(context, recipients_list, body, self.job_id, smtp, || {
-            async move {
-                // smtp success, update db ASAP, then delete smtp file
-                if 0 != foreign_id {
-                    set_delivered(context, MsgId::new(foreign_id)).await?;
-                }
-                // now also delete the generated file
-                dc_delete_file(context, filename).await;
-
-                // finally, create another send-job if there are items to be synced.
-                // triggering sync-job after msg-send-job guarantees, the recipient has grpid etc.
-                // once the sync message arrives.
-                // if there are no items to sync, this function returns fast.
-                context.send_sync_msg().await?;
-
-                Ok(())
-            }
-        })
-        .await
-    }
-
    /// Get `SendMdn` jobs with foreign_id equal to `contact_id` excluding the `job_id` job.
    async fn get_additional_mdn_jobs(
        &self,
@@ -535,14 +318,13 @@ impl Job {
            return Status::RetryLater;
        }

-        self.smtp_send(context, recipients, body, self.job_id, smtp, || {
-            async move {
-                // Remove additional SendMdn jobs we have aggregated into this one.
-                kill_ids(context, &additional_job_ids).await?;
-                Ok(())
-            }
-        })
-        .await
+        let status = smtp_send(context, &recipients, &body, smtp, msg_id, 0).await;
+        if matches!(status, Status::Finished(Ok(_))) {
+            // Remove additional SendMdn jobs we have aggregated into this one.
+            job_try!(kill_ids(context, &additional_job_ids).await);
+        }
+
+        status
    }

    /// Read the recipients from old emails sent by the user and add them as contacts.
@@ -703,17 +485,6 @@ pub async fn action_exists(context: &Context, action: Action) -> Result<bool> {
    Ok(exists)
 }

-async fn set_delivered(context: &Context, msg_id: MsgId) -> Result<()> {
-    message::update_msg_state(context, msg_id, MessageState::OutDelivered).await?;
-    let chat_id: ChatId = context
-        .sql
-        .query_get_value("SELECT chat_id FROM msgs WHERE id=?", paramsv![msg_id])
-        .await?
-        .unwrap_or_default();
-    context.emit_event(EventType::MsgDelivered { chat_id, msg_id });
-    Ok(())
-}
-
 async fn add_all_recipients_as_contacts(context: &Context, imap: &mut Imap, folder: Config) {
    let mailbox = if let Ok(Some(m)) = context.get_config(folder).await {
        m
@@ -759,132 +530,6 @@ async fn add_all_recipients_as_contacts(context: &Context, imap: &mut Imap, fold
    };
 }

-/// Constructs a job for sending a message.
-///
-/// Returns `None` if no messages need to be sent out.
-///
-/// In order to be processed, must be `add`ded.
-pub async fn send_msg_job(context: &Context, msg_id: MsgId) -> Result<Option<Job>> {
-    let mut msg = Message::load_from_db(context, msg_id).await?;
-    msg.try_calc_and_set_dimensions(context).await.ok();
-
-    /* create message */
-    let needs_encryption = msg.param.get_bool(Param::GuaranteeE2ee).unwrap_or_default();
-
-    let attach_selfavatar = match chat::shall_attach_selfavatar(context, msg.chat_id).await {
-        Ok(attach_selfavatar) => attach_selfavatar,
-        Err(err) => {
-            warn!(context, "job: cannot get selfavatar-state: {}", err);
-            false
-        }
-    };
-
-    let mimefactory = MimeFactory::from_msg(context, &msg, attach_selfavatar).await?;
-
-    let mut recipients = mimefactory.recipients();
-
-    let from = context
-        .get_config(Config::ConfiguredAddr)
-        .await?
-        .unwrap_or_default();
-    let lowercase_from = from.to_lowercase();
-
-    // Send BCC to self if it is enabled and we are not going to
-    // delete it immediately.
-    if context.get_config_bool(Config::BccSelf).await?
-        && context.get_config_delete_server_after().await? != Some(0)
-        && !recipients
-            .iter()
-            .any(|x| x.to_lowercase() == lowercase_from)
-    {
-        recipients.push(from);
-    }
-
-    if recipients.is_empty() {
-        // 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).await?;
-        return Ok(None);
-    }
-
-    let rendered_msg = match mimefactory.render(context).await {
-        Ok(res) => Ok(res),
-        Err(err) => {
-            message::set_msg_failed(context, msg_id, Some(err.to_string())).await;
-            Err(err)
-        }
-    }?;
-
-    if needs_encryption && !rendered_msg.is_encrypted {
-        /* unrecoverable */
-        message::set_msg_failed(
-            context,
-            msg_id,
-            Some("End-to-end-encryption unavailable unexpectedly."),
-        )
-        .await;
-        bail!(
-            "e2e encryption unavailable {} - {:?}",
-            msg_id,
-            needs_encryption
-        );
-    }
-
-    if rendered_msg.is_gossiped {
-        msg.chat_id.set_gossiped_timestamp(context, time()).await?;
-    }
-
-    if 0 != rendered_msg.last_added_location_id {
-        if let Err(err) = location::set_kml_sent_timestamp(context, msg.chat_id, time()).await {
-            error!(context, "Failed to set kml sent_timestamp: {:?}", err);
-        }
-        if !msg.hidden {
-            if let Err(err) =
-                location::set_msg_location_id(context, msg.id, rendered_msg.last_added_location_id)
-                    .await
-            {
-                error!(context, "Failed to set msg_location_id: {:?}", err);
-            }
-        }
-    }
-
-    if let Some(sync_ids) = rendered_msg.sync_ids_to_delete {
-        if let Err(err) = context.delete_sync_ids(sync_ids).await {
-            error!(context, "Failed to delete sync ids: {:?}", err);
-        }
-    }
-
-    if attach_selfavatar {
-        if let Err(err) = msg.chat_id.set_selfavatar_timestamp(context, time()).await {
-            error!(context, "Failed to set selfavatar timestamp: {:?}", err);
-        }
-    }
-
-    if rendered_msg.is_encrypted && !needs_encryption {
-        msg.param.set_int(Param::GuaranteeE2ee, 1);
-        msg.update_param(context).await;
-    }
-
-    ensure!(!recipients.is_empty(), "no recipients for smtp job set");
-    let mut param = Params::new();
-    let bytes = &rendered_msg.message;
-    let blob = BlobObject::create(context, &rendered_msg.rfc724_mid, bytes).await?;
-
-    let recipients = recipients.join("\x1e");
-    param.set(Param::File, blob.as_name());
-    param.set(Param::Recipients, &recipients);
-
-    msg.subject = rendered_msg.subject.clone();
-    msg.update_subject(context).await;
-
-    let job = create(Action::SendMsgToSmtp, msg_id.to_u32(), param, 0)?;
-
-    Ok(Some(job))
-}
-
 pub(crate) enum Connection<'a> {
    Inbox(&'a mut Imap),
    Smtp(&'a mut Smtp),
@@ -992,7 +637,6 @@ async fn perform_job_action(

    let try_res = match job.action {
        Action::Unknown => Status::Finished(Err(format_err!("Unknown job id found"))),
-        Action::SendMsgToSmtp => job.send_msg_to_smtp(context, connection.smtp()).await,
        Action::SendMdn => job.send_mdn(context, connection.smtp()).await,
        Action::MaybeSendLocations => location::job_maybe_send_locations(context, job).await,
        Action::MaybeSendLocationsEnded => {
@@ -1056,16 +700,6 @@ pub(crate) async fn schedule_resync(context: &Context) -> Result<()> {
    Ok(())
 }

-/// Creates a job.
-pub fn create(action: Action, foreign_id: u32, param: Params, delay_seconds: i64) -> Result<Job> {
-    ensure!(
-        action != Action::Unknown,
-        "Invalid action passed to job_add"
-    );
-
-    Ok(Job::new(action, foreign_id, param, delay_seconds))
-}
-
 /// Adds a job to the database, scheduling it.
 pub async fn add(context: &Context, job: Job) -> Result<()> {
    let action = job.action;
@@ -1084,10 +718,7 @@ pub async fn add(context: &Context, job: Job) -> Result<()> {
                info!(context, "interrupt: imap");
                context.interrupt_inbox(InterruptInfo::new(false)).await;
            }
-            Action::MaybeSendLocations
-            | Action::MaybeSendLocationsEnded
-            | Action::SendMdn
-            | Action::SendMsgToSmtp => {
+            Action::MaybeSendLocations | Action::MaybeSendLocationsEnded | Action::SendMdn => {
                info!(context, "interrupt: smtp");
                context.interrupt_smtp(InterruptInfo::new(false)).await;
            }
--- a/src/message.rs
+++ b/src/message.rs
@@ -113,10 +113,14 @@ WHERE id=?;
        Ok(())
    }

-    /// Deletes a message and corresponding MDNs from the database.
+    /// Deletes a message, corresponding MDNs and unsent SMTP messages from the database.
    pub async fn delete_from_db(self, context: &Context) -> Result<()> {
        // We don't use transactions yet, so remove MDNs first to make
        // sure they are not left while the message is deleted.
+        context
+            .sql
+            .execute("DELETE FROM smtp WHERE msg_id=?", paramsv![self])
+            .await?;
        context
            .sql
            .execute("DELETE FROM msgs_mdns WHERE msg_id=?;", paramsv![self])
@@ -135,6 +139,20 @@ WHERE id=?;
        Ok(())
    }

+    pub(crate) async fn set_delivered(self, context: &Context) -> Result<()> {
+        update_msg_state(context, self, MessageState::OutDelivered).await?;
+        let chat_id: ChatId = context
+            .sql
+            .query_get_value("SELECT chat_id FROM msgs WHERE id=?", paramsv![self])
+            .await?
+            .unwrap_or_default();
+        context.emit_event(EventType::MsgDelivered {
+            chat_id,
+            msg_id: self,
+        });
+        Ok(())
+    }
+
    /// Bad evil escape hatch.
    ///
    /// Avoid using this, eventually types should be cleaned up enough
@@ -162,7 +180,7 @@ impl rusqlite::types::ToSql for MsgId {
    fn to_sql(&self) -> rusqlite::Result<rusqlite::types::ToSqlOutput> {
        if self.0 <= DC_MSG_ID_LAST_SPECIAL {
            return Err(rusqlite::Error::ToSqlConversionFailure(
-                format_err!("Invalid MsgId").into(),
+                format_err!("Invalid MsgId {}", self.0).into(),
            ));
        }
        let val = rusqlite::types::Value::Integer(self.0 as i64);
@@ -812,7 +830,7 @@ impl Message {
        Ok(None)
    }

-    pub(crate) async fn parent(&self, context: &Context) -> Result<Option<Message>> {
+    pub async fn parent(&self, context: &Context) -> Result<Option<Message>> {
        if let Some(in_reply_to) = &self.in_reply_to {
            if let Some(msg_id) = rfc724_mid_exists(context, in_reply_to).await? {
                let msg = Message::load_from_db(context, msg_id).await?;
--- a/src/mimefactory.rs
+++ b/src/mimefactory.rs
@@ -81,7 +81,7 @@ pub struct MimeFactory<'a> {
 /// Result of rendering a message, ready to be submitted to a send job.
 #[derive(Debug, Clone)]
 pub struct RenderedEmail {
-    pub message: Vec<u8>,
+    pub message: String,
    // pub envelope: Envelope,
    pub is_encrypted: bool,
    pub is_gossiped: bool,
@@ -770,7 +770,7 @@ impl<'a> MimeFactory<'a> {
        } = self;

        Ok(RenderedEmail {
-            message: outer_message.build().as_string().into_bytes(),
+            message: outer_message.build().as_string(),
            // envelope: Envelope::new,
            is_encrypted,
            is_gossiped,
@@ -1328,8 +1328,7 @@ async fn build_body_file(
            "video_{}.{}",
            chrono::Utc
                .timestamp(msg.timestamp_sort, 0)
-                .format("%Y-%m-%d_%H-%M-%S")
-                .to_string(),
+                .format("%Y-%m-%d_%H-%M-%S"),
            &suffix
        ),
        _ => blob.as_file_name().to_string(),
@@ -1932,7 +1931,7 @@ mod tests {

        let rendered_msg = mimefactory.render(context).await.unwrap();

-        let mail = mailparse::parse_mail(&rendered_msg.message).unwrap();
+        let mail = mailparse::parse_mail(rendered_msg.message.as_bytes()).unwrap();
        assert_eq!(
            mail.headers
                .iter()
@@ -1942,7 +1941,7 @@ mod tests {
            "1.0"
        );

-        let _mime_msg = MimeMessage::from_bytes(context, &rendered_msg.message)
+        let _mime_msg = MimeMessage::from_bytes(context, rendered_msg.message.as_bytes())
            .await
            .unwrap();
    }
@@ -2016,8 +2015,9 @@ mod tests {
        let mut msg = Message::new(Viewtype::Text);
        msg.set_text(Some("this is the text!".to_string()));

-        let payload = t.send_msg(chat.id, &mut msg).await.payload();
-        let mut payload = payload.splitn(3, "\r\n\r\n");
+        let sent_msg = t.send_msg(chat.id, &mut msg).await;
+        let mut payload = sent_msg.payload().splitn(3, "\r\n\r\n");
+
        let outer = payload.next().unwrap();
        let inner = payload.next().unwrap();
        let body = payload.next().unwrap();
@@ -2035,8 +2035,8 @@ mod tests {

        // if another message is sent, that one must not contain the avatar
        // and no artificial multipart/mixed nesting
-        let payload = t.send_msg(chat.id, &mut msg).await.payload();
-        let mut payload = payload.splitn(2, "\r\n\r\n");
+        let sent_msg = t.send_msg(chat.id, &mut msg).await;
+        let mut payload = sent_msg.payload().splitn(2, "\r\n\r\n");
        let outer = payload.next().unwrap();
        let body = payload.next().unwrap();

--- a/src/mimeparser.rs
+++ b/src/mimeparser.rs
@@ -403,16 +403,18 @@ impl MimeMessage {
    #[allow(clippy::indexing_slicing)]
    fn squash_attachment_parts(&mut self) {
        if let [textpart, filepart] = &self.parts[..] {
-            let need_drop = {
-                textpart.typ == Viewtype::Text
-                    && (filepart.typ == Viewtype::Image
-                        || filepart.typ == Viewtype::Gif
-                        || filepart.typ == Viewtype::Sticker
-                        || filepart.typ == Viewtype::Audio
-                        || filepart.typ == Viewtype::Voice
-                        || filepart.typ == Viewtype::Video
-                        || filepart.typ == Viewtype::File)
-            };
+            let need_drop = textpart.typ == Viewtype::Text
+                && match filepart.typ {
+                    Viewtype::Image
+                    | Viewtype::Gif
+                    | Viewtype::Sticker
+                    | Viewtype::Audio
+                    | Viewtype::Voice
+                    | Viewtype::Video
+                    | Viewtype::File
+                    | Viewtype::Webxdc => true,
+                    Viewtype::Unknown | Viewtype::Text | Viewtype::VideochatInvitation => false,
+                };

            if need_drop {
                let mut filepart = self.parts.swap_remove(1);
--- a/src/param.rs
+++ b/src/param.rs
@@ -110,9 +110,6 @@ pub enum Param {
    /// For Jobs
    AlsoMove = b'M',

-    /// For Jobs: space-separated list of message recipients
-    Recipients = b'R',
-
    /// For MDN-sending job
    MsgId = b'I',

@@ -171,6 +168,12 @@ pub enum Param {

    /// For Chats: timestamp of protection settings update.
    ProtectionSettingsTimestamp = b'L',
+
+    /// For Webxdc Message Instances: Current summary
+    WebxdcSummary = b'N',
+
+    /// For Webxdc Message Instances: timestamp of summary update.
+    WebxdcSummaryTimestamp = b'Q',
 }

 /// An object for handling key=value parameter lists.
--- a/src/provider/data.rs
+++ b/src/provider/data.rs
@@ -366,7 +366,7 @@ static P_EXAMPLE_COM: Lazy<Provider> = Lazy::new(|| {
 }
 });

-// fastmail.md: fastmail.com
+// fastmail.md: 123mail.org, 150mail.com, 150ml.com, 16mail.com, 2-mail.com, 4email.net, 50mail.com, airpost.net, allmail.net, bestmail.us, cluemail.com, elitemail.org, emailcorner.net, emailengine.net, emailengine.org, emailgroups.net, emailplus.org, emailuser.net, eml.cc, f-m.fm, fast-email.com, fast-mail.org, fastem.com, fastemail.us, fastemailer.com, fastest.cc, fastimap.com, fastmail.cn, fastmail.co.uk, fastmail.com, fastmail.com.au, fastmail.de, fastmail.es, fastmail.fm, fastmail.fr, fastmail.im, fastmail.in, fastmail.jp, fastmail.mx, fastmail.net, fastmail.nl, fastmail.org, fastmail.se, fastmail.to, fastmail.tw, fastmail.uk, fastmail.us, fastmailbox.net, fastmessaging.com, fea.st, fmail.co.uk, fmailbox.com, fmgirl.com, fmguy.com, ftml.net, h-mail.us, hailmail.net, imap-mail.com, imap.cc, imapmail.org, inoutbox.com, internet-e-mail.com, internet-mail.org, internetemails.net, internetmailing.net, jetemail.net, justemail.net, letterboxes.org, mail-central.com, mail-page.com, mailandftp.com, mailas.com, mailbolt.com, mailc.net, mailcan.com, mailforce.net, mailftp.com, mailhaven.com, mailingaddress.org, mailite.com, mailmight.com, mailnew.com, mailsent.net, mailservice.ms, mailup.net, mailworks.org, ml1.net, mm.st, myfastmail.com, mymacmail.com, nospammail.net, ownmail.net, petml.com, postinbox.com, postpro.net, proinbox.com, promessage.com, realemail.net, reallyfast.biz, reallyfast.info, rushpost.com, sent.as, sent.at, sent.com, speedpost.net, speedymail.org, ssl-mail.com, swift-mail.com, the-fastest.net, the-quickest.com, theinternetemail.com, veryfast.biz, veryspeedy.net, warpmail.net, xsmail.com, yepmail.net, your-mail.com
 static P_FASTMAIL: Lazy<Provider> = Lazy::new(|| Provider {
    id: "fastmail",
    status: Status::Preparation,
@@ -389,13 +389,6 @@ static P_FASTMAIL: Lazy<Provider> = Lazy::new(|| Provider {
            port: 465,
            username_pattern: Email,
        },
-        Server {
-            protocol: Smtp,
-            socket: Starttls,
-            hostname: "smtp.fastmail.com",
-            port: 587,
-            username_pattern: Email,
-        },
    ],
    config_defaults: None,
    strict_tls: true,
@@ -716,8 +709,8 @@ static P_MAIL_DE: Lazy<Provider> = Lazy::new(|| Provider {
 static P_MAIL_RU: Lazy<Provider> = Lazy::new(|| {
    Provider {
    id: "mail.ru",
-    status: Status::Ok,
-    before_login_hint: "Не рекомендуется использовать mail.ru, потому что он разряжает вашу батарею быстрее, чем другие провайдеры.",
+    status: Status::Preparation,
+    before_login_hint: "Вам необходимо сгенерировать \"пароль для внешнего приложения\" в веб-интерфейсе mail.ru, чтобы mail.ru работал с Delta Chat.",
    after_login_hint: "",
    overview_page: "https://providers.delta.chat/mail-ru",
    server: vec![
@@ -905,7 +898,7 @@ static P_NAVER: Lazy<Provider> = Lazy::new(|| Provider {
    oauth2_authorizer: None,
 });

-// outlook.com.md: hotmail.com, outlook.com, office365.com, outlook.com.tr, live.com
+// outlook.com.md: hotmail.com, outlook.com, office365.com, outlook.com.tr, live.com, outlook.de
 static P_OUTLOOK_COM: Lazy<Provider> = Lazy::new(|| Provider {
    id: "outlook.com",
    status: Status::Ok,
@@ -1495,7 +1488,123 @@ pub(crate) static PROVIDER_DATA: Lazy<HashMap<&'static str, &'static Provider>>
        ("example.com", &*P_EXAMPLE_COM),
        ("example.org", &*P_EXAMPLE_COM),
        ("example.net", &*P_EXAMPLE_COM),
+        ("123mail.org", &*P_FASTMAIL),
+        ("150mail.com", &*P_FASTMAIL),
+        ("150ml.com", &*P_FASTMAIL),
+        ("16mail.com", &*P_FASTMAIL),
+        ("2-mail.com", &*P_FASTMAIL),
+        ("4email.net", &*P_FASTMAIL),
+        ("50mail.com", &*P_FASTMAIL),
+        ("airpost.net", &*P_FASTMAIL),
+        ("allmail.net", &*P_FASTMAIL),
+        ("bestmail.us", &*P_FASTMAIL),
+        ("cluemail.com", &*P_FASTMAIL),
+        ("elitemail.org", &*P_FASTMAIL),
+        ("emailcorner.net", &*P_FASTMAIL),
+        ("emailengine.net", &*P_FASTMAIL),
+        ("emailengine.org", &*P_FASTMAIL),
+        ("emailgroups.net", &*P_FASTMAIL),
+        ("emailplus.org", &*P_FASTMAIL),
+        ("emailuser.net", &*P_FASTMAIL),
+        ("eml.cc", &*P_FASTMAIL),
+        ("f-m.fm", &*P_FASTMAIL),
+        ("fast-email.com", &*P_FASTMAIL),
+        ("fast-mail.org", &*P_FASTMAIL),
+        ("fastem.com", &*P_FASTMAIL),
+        ("fastemail.us", &*P_FASTMAIL),
+        ("fastemailer.com", &*P_FASTMAIL),
+        ("fastest.cc", &*P_FASTMAIL),
+        ("fastimap.com", &*P_FASTMAIL),
+        ("fastmail.cn", &*P_FASTMAIL),
+        ("fastmail.co.uk", &*P_FASTMAIL),
        ("fastmail.com", &*P_FASTMAIL),
+        ("fastmail.com.au", &*P_FASTMAIL),
+        ("fastmail.de", &*P_FASTMAIL),
+        ("fastmail.es", &*P_FASTMAIL),
+        ("fastmail.fm", &*P_FASTMAIL),
+        ("fastmail.fr", &*P_FASTMAIL),
+        ("fastmail.im", &*P_FASTMAIL),
+        ("fastmail.in", &*P_FASTMAIL),
+        ("fastmail.jp", &*P_FASTMAIL),
+        ("fastmail.mx", &*P_FASTMAIL),
+        ("fastmail.net", &*P_FASTMAIL),
+        ("fastmail.nl", &*P_FASTMAIL),
+        ("fastmail.org", &*P_FASTMAIL),
+        ("fastmail.se", &*P_FASTMAIL),
+        ("fastmail.to", &*P_FASTMAIL),
+        ("fastmail.tw", &*P_FASTMAIL),
+        ("fastmail.uk", &*P_FASTMAIL),
+        ("fastmail.us", &*P_FASTMAIL),
+        ("fastmailbox.net", &*P_FASTMAIL),
+        ("fastmessaging.com", &*P_FASTMAIL),
+        ("fea.st", &*P_FASTMAIL),
+        ("fmail.co.uk", &*P_FASTMAIL),
+        ("fmailbox.com", &*P_FASTMAIL),
+        ("fmgirl.com", &*P_FASTMAIL),
+        ("fmguy.com", &*P_FASTMAIL),
+        ("ftml.net", &*P_FASTMAIL),
+        ("h-mail.us", &*P_FASTMAIL),
+        ("hailmail.net", &*P_FASTMAIL),
+        ("imap-mail.com", &*P_FASTMAIL),
+        ("imap.cc", &*P_FASTMAIL),
+        ("imapmail.org", &*P_FASTMAIL),
+        ("inoutbox.com", &*P_FASTMAIL),
+        ("internet-e-mail.com", &*P_FASTMAIL),
+        ("internet-mail.org", &*P_FASTMAIL),
+        ("internetemails.net", &*P_FASTMAIL),
+        ("internetmailing.net", &*P_FASTMAIL),
+        ("jetemail.net", &*P_FASTMAIL),
+        ("justemail.net", &*P_FASTMAIL),
+        ("letterboxes.org", &*P_FASTMAIL),
+        ("mail-central.com", &*P_FASTMAIL),
+        ("mail-page.com", &*P_FASTMAIL),
+        ("mailandftp.com", &*P_FASTMAIL),
+        ("mailas.com", &*P_FASTMAIL),
+        ("mailbolt.com", &*P_FASTMAIL),
+        ("mailc.net", &*P_FASTMAIL),
+        ("mailcan.com", &*P_FASTMAIL),
+        ("mailforce.net", &*P_FASTMAIL),
+        ("mailftp.com", &*P_FASTMAIL),
+        ("mailhaven.com", &*P_FASTMAIL),
+        ("mailingaddress.org", &*P_FASTMAIL),
+        ("mailite.com", &*P_FASTMAIL),
+        ("mailmight.com", &*P_FASTMAIL),
+        ("mailnew.com", &*P_FASTMAIL),
+        ("mailsent.net", &*P_FASTMAIL),
+        ("mailservice.ms", &*P_FASTMAIL),
+        ("mailup.net", &*P_FASTMAIL),
+        ("mailworks.org", &*P_FASTMAIL),
+        ("ml1.net", &*P_FASTMAIL),
+        ("mm.st", &*P_FASTMAIL),
+        ("myfastmail.com", &*P_FASTMAIL),
+        ("mymacmail.com", &*P_FASTMAIL),
+        ("nospammail.net", &*P_FASTMAIL),
+        ("ownmail.net", &*P_FASTMAIL),
+        ("petml.com", &*P_FASTMAIL),
+        ("postinbox.com", &*P_FASTMAIL),
+        ("postpro.net", &*P_FASTMAIL),
+        ("proinbox.com", &*P_FASTMAIL),
+        ("promessage.com", &*P_FASTMAIL),
+        ("realemail.net", &*P_FASTMAIL),
+        ("reallyfast.biz", &*P_FASTMAIL),
+        ("reallyfast.info", &*P_FASTMAIL),
+        ("rushpost.com", &*P_FASTMAIL),
+        ("sent.as", &*P_FASTMAIL),
+        ("sent.at", &*P_FASTMAIL),
+        ("sent.com", &*P_FASTMAIL),
+        ("speedpost.net", &*P_FASTMAIL),
+        ("speedymail.org", &*P_FASTMAIL),
+        ("ssl-mail.com", &*P_FASTMAIL),
+        ("swift-mail.com", &*P_FASTMAIL),
+        ("the-fastest.net", &*P_FASTMAIL),
+        ("the-quickest.com", &*P_FASTMAIL),
+        ("theinternetemail.com", &*P_FASTMAIL),
+        ("veryfast.biz", &*P_FASTMAIL),
+        ("veryspeedy.net", &*P_FASTMAIL),
+        ("warpmail.net", &*P_FASTMAIL),
+        ("xsmail.com", &*P_FASTMAIL),
+        ("yepmail.net", &*P_FASTMAIL),
+        ("your-mail.com", &*P_FASTMAIL),
        ("firemail.at", &*P_FIREMAIL_DE),
        ("firemail.de", &*P_FIREMAIL_DE),
        ("five.chat", &*P_FIVE_CHAT),
@@ -1539,6 +1648,7 @@ pub(crate) static PROVIDER_DATA: Lazy<HashMap<&'static str, &'static Provider>>
        ("office365.com", &*P_OUTLOOK_COM),
        ("outlook.com.tr", &*P_OUTLOOK_COM),
        ("live.com", &*P_OUTLOOK_COM),
+        ("outlook.de", &*P_OUTLOOK_COM),
        ("posteo.de", &*P_POSTEO),
        ("posteo.af", &*P_POSTEO),
        ("posteo.at", &*P_POSTEO),
@@ -1743,4 +1853,4 @@ pub(crate) static PROVIDER_IDS: Lazy<HashMap<&'static str, &'static Provider>> =
 });

 pub static PROVIDER_UPDATED: Lazy<chrono::NaiveDate> =
-    Lazy::new(|| chrono::NaiveDate::from_ymd(2022, 1, 11));
+    Lazy::new(|| chrono::NaiveDate::from_ymd(2022, 1, 31));
--- a/src/scheduler.rs
+++ b/src/scheduler.rs
@@ -1,4 +1,4 @@
-use anyhow::{bail, Result};
+use anyhow::{bail, Context as _, Result};
 use async_std::prelude::*;
 use async_std::{
    channel::{self, Receiver, Sender},
@@ -8,9 +8,10 @@ use async_std::{
 use crate::config::Config;
 use crate::context::Context;
 use crate::dc_tools::maybe_add_time_based_warnings;
+use crate::ephemeral::delete_expired_imap_messages;
 use crate::imap::Imap;
 use crate::job::{self, Thread};
-use crate::smtp::Smtp;
+use crate::smtp::{send_smtp_messages, Smtp};

 use self::connectivity::ConnectivityStore;

@@ -160,20 +161,56 @@ async fn fetch_idle(ctx: &Context, connection: &mut Imap, folder: Config) -> Int
                return connection.fake_idle(ctx, Some(watch_folder)).await;
            }

-            // Scan other folders before fetching from watched folder. This may result in the
-            // messages being moved into the watched folder, for example from the Spam folder to
-            // the Inbox folder.
+            // Mark expired messages for deletion.
+            if let Err(err) = delete_expired_imap_messages(ctx)
+                .await
+                .context("delete_expired_imap_messages failed")
+            {
+                warn!(ctx, "{:#}", err);
+            }
+
+            // Fetch the watched folder.
+            if let Err(err) = connection.fetch_move_delete(ctx, &watch_folder).await {
+                connection.trigger_reconnect(ctx).await;
+                warn!(ctx, "{:#}", err);
+                return InterruptInfo::new(false);
+            }
+
+            // Scan additional folders only after finishing fetching the watched folder.
+            //
+            // On iOS the application has strictly limited time to work in background, so we may not
+            // be able to scan all folders before time is up if there are many of them.
            if folder == Config::ConfiguredInboxFolder {
                // Only scan on the Inbox thread in order to prevent parallel scans, which might lead to duplicate messages
-                if let Err(err) = connection.scan_folders(ctx).await {
-                    // Don't reconnect, if there is a problem with the connection we will realize this when IDLEing
-                    // but maybe just one folder can't be selected or something
-                    warn!(ctx, "{}", err);
+                match connection.scan_folders(ctx).await {
+                    Err(err) => {
+                        // Don't reconnect, if there is a problem with the connection we will realize this when IDLEing
+                        // but maybe just one folder can't be selected or something
+                        warn!(ctx, "{}", err);
+                    }
+                    Ok(true) => {
+                        // Fetch the watched folder again in case scanning other folder moved messages
+                        // there.
+                        //
+                        // In most cases this will select the watched folder and return because there are
+                        // no new messages. We want to select the watched folder anyway before going IDLE
+                        // there, so this does not take additional protocol round-trip.
+                        if let Err(err) = connection.fetch_move_delete(ctx, &watch_folder).await {
+                            connection.trigger_reconnect(ctx).await;
+                            warn!(ctx, "{:#}", err);
+                            return InterruptInfo::new(false);
+                        }
+                    }
+                    Ok(false) => {}
                }
            }

-            // fetch
-            if let Err(err) = connection.fetch_move_delete(ctx, &watch_folder).await {
+            // Synchronize Seen flags.
+            if let Err(err) = connection
+                .sync_seen_flags(ctx, &watch_folder)
+                .await
+                .context("sync_seen_flags")
+            {
                connection.trigger_reconnect(ctx).await;
                warn!(ctx, "{:#}", err);
                return InterruptInfo::new(false);
@@ -273,17 +310,25 @@ async fn smtp_loop(ctx: Context, started: Sender<()>, smtp_handlers: SmtpConnect

        let mut interrupt_info = Default::default();
        loop {
-            match job::load_next(&ctx, Thread::Smtp, &interrupt_info)
-                .await
-                .ok()
-                .flatten()
-            {
+            let job = match job::load_next(&ctx, Thread::Smtp, &interrupt_info).await {
+                Err(err) => {
+                    error!(ctx, "Failed loading job from the database: {:#}.", err);
+                    None
+                }
+                Ok(job) => job,
+            };
+
+            match job {
                Some(job) => {
                    info!(ctx, "executing smtp job");
                    job::perform_job(&ctx, job::Connection::Smtp(&mut connection), job).await;
                    interrupt_info = Default::default();
                }
                None => {
+                    if let Err(err) = send_smtp_messages(&ctx, &mut connection).await {
+                        warn!(ctx, "send_smtp_messages failed: {:#}", err);
+                    }
+
                    // Fake Idle
                    info!(ctx, "smtp fake idle - started");
                    match &connection.last_send_error {
@@ -333,7 +378,7 @@ impl Scheduler {
            }))
        };

-        if ctx.get_config_bool(Config::MvboxMove).await? {
+        if ctx.should_watch_mvbox().await? {
            let ctx = ctx.clone();
            mvbox_handle = Some(task::spawn(async move {
                simple_imap_loop(
--- a/src/scheduler/connectivity.rs
+++ b/src/scheduler/connectivity.rs
@@ -5,6 +5,7 @@ use async_std::sync::{Mutex, RwLockReadGuard};

 use crate::dc_tools::time;
 use crate::events::EventType;
+use crate::imap::scan_folders::get_watched_folder_configs;
 use crate::quota::{
    QUOTA_ERROR_THRESHOLD_PERCENTAGE, QUOTA_MAX_AGE_SECONDS, QUOTA_WARN_THRESHOLD_PERCENTAGE,
 };
@@ -362,17 +363,14 @@ impl Context {
                [
                    (
                        Config::ConfiguredInboxFolder,
-                        None,
                        inbox.state.connectivity.clone(),
                    ),
                    (
                        Config::ConfiguredMvboxFolder,
-                        Some(Config::MvboxMove),
                        mvbox.state.connectivity.clone(),
                    ),
                    (
                        Config::ConfiguredSentboxFolder,
-                        Some(Config::SentboxWatch),
                        sentbox.state.connectivity.clone(),
                    ),
                ],
@@ -391,20 +389,12 @@ impl Context {
        //                               - "Sent": Connected
        // =============================================================================================

+        let watched_folders = get_watched_folder_configs(self).await?;
        ret += &format!("<h3>{}</h3><ul>", stock_str::incoming_messages(self).await);
-        for (folder, watch, state) in &folders_states {
-            let w = if let Some(watch_config) = *watch {
-                self.get_config(watch_config)
-                    .await
-                    .ok_or_log(self)
-                    .flatten()
-                    == Some("1".to_string())
-            } else {
-                true
-            };
-
+        for (folder, state) in &folders_states {
            let mut folder_added = false;
-            if w {
+
+            if watched_folders.contains(folder) {
                let f = self.get_config(*folder).await.ok_or_log(self).flatten();

                if let Some(foldername) = f {
--- a/src/smtp.rs
+++ b/src/smtp.rs
@@ -4,14 +4,18 @@ pub mod send;

 use std::time::{Duration, SystemTime};

+use anyhow::{bail, format_err, Context as _, Result};
 use async_smtp::smtp::client::net::ClientTlsParameters;
-use async_smtp::{error, smtp, EmailAddress, ServerAddress};
+use async_smtp::smtp::response::{Category, Code, Detail};
+use async_smtp::{smtp, EmailAddress, ServerAddress};

 use crate::constants::DC_LP_AUTH_OAUTH2;
 use crate::events::EventType;
+use crate::job::Status;
 use crate::login_param::{
    dc_build_tls, CertificateChecks, LoginParam, ServerLoginParam, Socks5Config,
 };
+use crate::message::{self, MsgId};
 use crate::oauth2::dc_get_oauth2_access_token;
 use crate::provider::Socket;
 use crate::{context::Context, scheduler::connectivity::ConnectivityStore};
@@ -19,28 +23,6 @@ use crate::{context::Context, scheduler::connectivity::ConnectivityStore};
 /// SMTP write and read timeout in seconds.
 const SMTP_TIMEOUT: u64 = 30;

-#[derive(Debug, thiserror::Error)]
-pub enum Error {
-    #[error("Bad parameters")]
-    BadParameters,
-    #[error("Invalid login address {address}: {error}")]
-    InvalidLoginAddress {
-        address: String,
-        #[source]
-        error: error::Error,
-    },
-    #[error("SMTP failed to connect: {0}")]
-    ConnectionFailure(#[source] smtp::error::Error),
-    #[error("SMTP oauth2 error {address}")]
-    Oauth2 { address: String },
-    #[error("TLS error {0}")]
-    Tls(#[from] async_native_tls::Error),
-    #[error("{0}")]
-    Other(#[from] anyhow::Error),
-}
-
-pub type Result<T> = std::result::Result<T, Error>;
-
 #[derive(Default)]
 pub(crate) struct Smtp {
    transport: Option<smtp::SmtpTransport>,
@@ -131,14 +113,11 @@ impl Smtp {
        }

        if lp.server.is_empty() || lp.port == 0 {
-            return Err(Error::BadParameters);
+            bail!("bad connection parameters");
        }

-        let from =
-            EmailAddress::new(addr.to_string()).map_err(|err| Error::InvalidLoginAddress {
-                address: addr.to_string(),
-                error: err,
-            })?;
+        let from = EmailAddress::new(addr.to_string())
+            .with_context(|| format!("invalid login address {}", addr))?;

        self.from = Some(from);

@@ -159,9 +138,7 @@ impl Smtp {
            let send_pw = &lp.password;
            let access_token = dc_get_oauth2_access_token(context, addr, send_pw, false).await?;
            if access_token.is_none() {
-                return Err(Error::Oauth2 {
-                    address: addr.to_string(),
-                });
+                bail!("SMTP OAuth 2 error {}", addr);
            }
            let user = &lp.user;
            (
@@ -205,9 +182,7 @@ impl Smtp {
        }

        let mut trans = client.into_transport();
-        if let Err(err) = trans.connect().await {
-            return Err(Error::ConnectionFailure(err));
-        }
+        trans.connect().await.context("SMTP failed to connect")?;

        self.transport = Some(trans);
        self.last_success = Some(SystemTime::now());
@@ -220,3 +195,289 @@ impl Smtp {
        Ok(())
    }
 }
+
+/// Tries to send a message.
+///
+/// Returns Status::Finished if sending the message should not be retried anymore,
+/// Status::RetryLater if sending should be postponed and Status::RetryNow if it is suspected that
+/// temporary failure is caused by stale connection, in which case a second attempt to send the
+/// same message may be done immediately.
+pub(crate) async fn smtp_send(
+    context: &Context,
+    recipients: &[async_smtp::EmailAddress],
+    message: &str,
+    smtp: &mut Smtp,
+    msg_id: MsgId,
+    rowid: i64,
+) -> Status {
+    if std::env::var(crate::DCC_MIME_DEBUG).is_ok() {
+        info!(context, "smtp-sending out mime message:");
+        println!("{}", message);
+    }
+
+    smtp.connectivity.set_working(context).await;
+
+    let send_result = smtp
+        .send(context, recipients, message.as_bytes(), rowid)
+        .await;
+    smtp.last_send_error = send_result.as_ref().err().map(|e| e.to_string());
+
+    let status = match send_result {
+        Err(crate::smtp::send::Error::SmtpSend(err)) => {
+            // Remote error, retry later.
+            warn!(context, "SMTP failed to send: {:?}", &err);
+
+            let res = match err {
+                async_smtp::smtp::error::Error::Permanent(ref response) => {
+                    // Workaround for incorrectly configured servers returning permanent errors
+                    // instead of temporary ones.
+                    let maybe_transient = match response.code {
+                        // Sometimes servers send a permanent error when actually it is a temporary error
+                        // For documentation see <https://tools.ietf.org/html/rfc3463>
+                        Code {
+                            category: Category::MailSystem,
+                            detail: Detail::Zero,
+                            ..
+                        } => {
+                            // Ignore status code 5.5.0, see <https://support.delta.chat/t/every-other-message-gets-stuck/877/2>
+                            // Maybe incorrectly configured Postfix milter with "reject" instead of "tempfail", which returns
+                            // "550 5.5.0 Service unavailable" instead of "451 4.7.1 Service unavailable - try again later".
+                            //
+                            // Other enhanced status codes, such as Postfix
+                            // "550 5.1.1 <foobar@example.org>: Recipient address rejected: User unknown in local recipient table"
+                            // are not ignored.
+                            response.first_word() == Some(&"5.5.0".to_string())
+                        }
+                        _ => false,
+                    };
+
+                    if maybe_transient {
+                        Status::RetryLater
+                    } else {
+                        // If we do not retry, add an info message to the chat.
+                        // Yandex error "554 5.7.1 [2] Message rejected under suspicion of SPAM; https://ya.cc/..."
+                        // should definitely go here, because user has to open the link to
+                        // resume message sending.
+                        Status::Finished(Err(format_err!("Permanent SMTP error: {}", err)))
+                    }
+                }
+                async_smtp::smtp::error::Error::Transient(ref response) => {
+                    // We got a transient 4xx response from SMTP server.
+                    // Give some time until the server-side error maybe goes away.
+
+                    if let Some(first_word) = response.first_word() {
+                        if first_word.ends_with(".1.1")
+                            || first_word.ends_with(".1.2")
+                            || first_word.ends_with(".1.3")
+                        {
+                            // Sometimes we receive transient errors that should be permanent.
+                            // Any extended smtp status codes like x.1.1, x.1.2 or x.1.3 that we
+                            // receive as a transient error are misconfigurations of the smtp server.
+                            // See <https://tools.ietf.org/html/rfc3463#section-3.2>
+                            info!(context, "Received extended status code {} for a transient error. This looks like a misconfigured smtp server, let's fail immediatly", first_word);
+                            Status::Finished(Err(format_err!("Permanent SMTP error: {}", err)))
+                        } else {
+                            Status::RetryLater
+                        }
+                    } else {
+                        Status::RetryLater
+                    }
+                }
+                _ => {
+                    if smtp.has_maybe_stale_connection().await {
+                        info!(context, "stale connection? immediately reconnecting");
+                        Status::RetryNow
+                    } else {
+                        Status::RetryLater
+                    }
+                }
+            };
+
+            // this clears last_success info
+            smtp.disconnect().await;
+
+            res
+        }
+        Err(crate::smtp::send::Error::Envelope(err)) => {
+            // Local error, job is invalid, do not retry.
+            smtp.disconnect().await;
+            warn!(context, "SMTP job is invalid: {}", err);
+            Status::Finished(Err(err.into()))
+        }
+        Err(crate::smtp::send::Error::NoTransport) => {
+            // Should never happen.
+            // It does not even make sense to disconnect here.
+            error!(context, "SMTP job failed because SMTP has no transport");
+            Status::Finished(Err(format_err!("SMTP has not transport")))
+        }
+        Err(crate::smtp::send::Error::Other(err)) => {
+            // Local error, job is invalid, do not retry.
+            smtp.disconnect().await;
+            warn!(context, "unable to load job: {}", err);
+            Status::Finished(Err(err))
+        }
+        Ok(()) => Status::Finished(Ok(())),
+    };
+
+    if let Status::Finished(Err(err)) = &status {
+        // We couldn't send the message, so mark it as failed
+        message::set_msg_failed(context, msg_id, Some(err.to_string())).await;
+    }
+    status
+}
+
+/// Sends message identified by `smtp` table rowid over SMTP connection.
+///
+/// Removes row if the message should not be retried, otherwise increments retry count.
+pub(crate) async fn send_msg_to_smtp(
+    context: &Context,
+    smtp: &mut Smtp,
+    rowid: i64,
+) -> anyhow::Result<()> {
+    if let Err(err) = smtp
+        .connect_configured(context)
+        .await
+        .context("SMTP connection failure")
+    {
+        smtp.last_send_error = Some(format!("{:#}", err));
+        return Err(err);
+    }
+
+    let (body, recipients, msg_id) = context
+        .sql
+        .query_row(
+            "SELECT mime, recipients, msg_id FROM smtp WHERE id=?",
+            paramsv![rowid],
+            |row| {
+                let mime: String = row.get(0)?;
+                let recipients: String = row.get(1)?;
+                let msg_id: MsgId = row.get(2)?;
+                Ok((mime, recipients, msg_id))
+            },
+        )
+        .await?;
+    let recipients_list = recipients
+        .split(' ')
+        .filter_map(
+            |addr| match async_smtp::EmailAddress::new(addr.to_string()) {
+                Ok(addr) => Some(addr),
+                Err(err) => {
+                    warn!(context, "invalid recipient: {} {:?}", addr, err);
+                    None
+                }
+            },
+        )
+        .collect::<Vec<_>>();
+
+    // If there is a msg-id and it does not exist in the db, cancel sending. this happens if
+    // dc_delete_msgs() was called before the generated mime was sent out.
+    if !message::exists(context, msg_id)
+        .await
+        .with_context(|| format!("failed to check message {} existence", msg_id))?
+    {
+        info!(
+            context,
+            "Sending of message {} was cancelled by the user.", msg_id
+        );
+        return Ok(());
+    }
+
+    let status = match smtp_send(
+        context,
+        &recipients_list,
+        body.as_str(),
+        smtp,
+        msg_id,
+        rowid,
+    )
+    .await
+    {
+        Status::RetryNow => {
+            // Do a single retry immediately without increasing retry counter in case of stale
+            // connection.
+            info!(context, "Doing immediate retry to send message.");
+
+            // smtp_send just closed stale SMTP connection, reconnect and try again.
+            if let Err(err) = smtp
+                .connect_configured(context)
+                .await
+                .context("failed to reopen stale SMTP connection")
+            {
+                smtp.last_send_error = Some(format!("{:#}", err));
+                return Err(err);
+            }
+
+            smtp_send(
+                context,
+                &recipients_list,
+                body.as_str(),
+                smtp,
+                msg_id,
+                rowid,
+            )
+            .await
+        }
+        status => status,
+    };
+    match status {
+        Status::Finished(res) => {
+            if res.is_ok() {
+                msg_id.set_delivered(context).await?;
+
+                context
+                    .sql
+                    .execute("DELETE FROM smtp WHERE id=?", paramsv![rowid])
+                    .await?;
+            }
+            res
+        }
+        Status::RetryNow | Status::RetryLater => {
+            context
+                .sql
+                .execute(
+                    "UPDATE smtp SET retries=retries+1 WHERE id=?",
+                    paramsv![rowid],
+                )
+                .await
+                .context("failed to update retries count")?;
+            Err(format_err!("Retry"))
+        }
+    }
+}
+
+/// Tries to send all messages currently in `smtp` table.
+///
+/// Logs and ignores SMTP errors to ensure that a single SMTP message constantly failing to be sent
+/// does not block other messages in the queue from being sent.
+pub(crate) async fn send_smtp_messages(
+    context: &Context,
+    connection: &mut Smtp,
+) -> anyhow::Result<()> {
+    context.send_sync_msg().await?; // Add sync message to the end of the queue if needed.
+    context
+        .sql
+        .execute("DELETE FROM smtp WHERE retries > 5", paramsv![])
+        .await?;
+    let rowids = context
+        .sql
+        .query_map(
+            "SELECT id FROM smtp ORDER BY id ASC",
+            paramsv![],
+            |row| {
+                let rowid: i64 = row.get(0)?;
+                Ok(rowid)
+            },
+            |rowids| {
+                rowids
+                    .collect::<std::result::Result<Vec<_>, _>>()
+                    .map_err(Into::into)
+            },
+        )
+        .await?;
+    for rowid in rowids {
+        if let Err(err) = send_msg_to_smtp(context, connection, rowid).await {
+            info!(context, "Failed to send message over SMTP: {:#}.", err);
+        }
+    }
+    Ok(())
+}
--- a/src/smtp/send.rs
+++ b/src/smtp/send.rs
@@ -28,9 +28,9 @@ impl Smtp {
    pub async fn send(
        &mut self,
        context: &Context,
-        recipients: Vec<EmailAddress>,
-        message: Vec<u8>,
-        job_id: u32,
+        recipients: &[EmailAddress],
+        message: &[u8],
+        rowid: i64,
    ) -> Result<()> {
        let message_len_bytes = message.len();

@@ -41,7 +41,7 @@ impl Smtp {
            }
        }

-        for recipients_chunk in recipients.chunks(chunk_size).into_iter() {
+        for recipients_chunk in recipients.chunks(chunk_size) {
            let recipients_display = recipients_chunk
                .iter()
                .map(|x| x.as_ref())
@@ -52,8 +52,8 @@ impl Smtp {
                .map_err(Error::Envelope)?;
            let mail = SendableEmail::new(
                envelope,
-                format!("{}", job_id), // only used for internal logging
-                &message,
+                rowid.to_string(), // only used for internal logging
+                message,
            );

            if let Some(ref mut transport) = self.transport {
--- a/src/sql.rs
+++ b/src/sql.rs
@@ -10,7 +10,7 @@ use std::time::Duration;
 use anyhow::{bail, Context as _, Result};
 use async_std::path::PathBuf;
 use async_std::prelude::*;
-use rusqlite::{Connection, OpenFlags};
+use rusqlite::{config::DbConfig, Connection, OpenFlags};

 use crate::blob::BlobObject;
 use crate::chat::{add_device_msg, update_device_icon, update_saved_messages_icon};
@@ -44,10 +44,9 @@ pub struct Sql {

    pool: RwLock<Option<r2d2::Pool<r2d2_sqlite::SqliteConnectionManager>>>,

-    /// SQLCipher passphrase.
-    ///
-    /// Empty string if database is not encrypted.
-    passphrase: RwLock<String>,
+    /// None if the database is not open, true if it is open with passphrase and false if it is
+    /// open without a passphrase.
+    is_encrypted: RwLock<Option<bool>>,
 }

 impl Sql {
@@ -55,18 +54,18 @@ impl Sql {
        Self {
            dbfile,
            pool: Default::default(),
-            passphrase: Default::default(),
+            is_encrypted: Default::default(),
        }
    }

-    /// Sets SQLCipher passphrase for key derivation.
+    /// Tests SQLCipher passphrase.
    ///
    /// Returns true if passphrase is correct, i.e. the database is new or can be unlocked with
    /// this passphrase, and false if the database is already encrypted with another passphrase or
    /// corrupted.
    ///
    /// Fails if database is already open.
-    pub async fn set_passphrase(&self, passphrase: String) -> Result<bool> {
+    pub async fn check_passphrase(&self, passphrase: String) -> Result<bool> {
        if self.is_open().await {
            bail!("Database is already opened.");
        }
@@ -83,10 +82,6 @@ impl Sql {
            .query_row("SELECT count(*) FROM sqlite_master", [], |_row| Ok(()))
            .is_ok();

-        if key_is_correct {
-            *self.passphrase.write().await = passphrase;
-        }
-
        Ok(key_is_correct)
    }

@@ -95,12 +90,75 @@ impl Sql {
        self.pool.read().await.is_some()
    }

+    /// Returns true if the database is encrypted.
+    ///
+    /// If database is not open, returns `None`.
+    pub(crate) async fn is_encrypted(&self) -> Option<bool> {
+        *self.is_encrypted.read().await
+    }
+
    /// Closes all underlying Sqlite connections.
-    pub async fn close(&self) {
+    async fn close(&self) {
        let _ = self.pool.write().await.take();
        // drop closes the connection
    }

+    /// Exports the database to a separate file with the given passphrase.
+    ///
+    /// Set passphrase to empty string to export the database unencrypted.
+    pub(crate) async fn export(&self, path: &Path, passphrase: String) -> Result<()> {
+        let path_str = path
+            .to_str()
+            .with_context(|| format!("path {:?} is not valid unicode", path))?;
+        let conn = self.get_conn().await?;
+        conn.execute(
+            "ATTACH DATABASE ? AS backup KEY ?",
+            paramsv![path_str, passphrase],
+        )
+        .context("failed to attach backup database")?;
+        let res = conn
+            .query_row("SELECT sqlcipher_export('backup')", [], |_row| Ok(()))
+            .context("failed to export to attached backup database");
+        conn.execute("DETACH DATABASE backup", [])
+            .context("failed to detach backup database")?;
+        res?;
+        Ok(())
+    }
+
+    /// Imports the database from a separate file with the given passphrase.
+    pub(crate) async fn import(&self, path: &Path, passphrase: String) -> Result<()> {
+        let path_str = path
+            .to_str()
+            .with_context(|| format!("path {:?} is not valid unicode", path))?;
+        let conn = self.get_conn().await?;
+
+        // Reset the database without reopening it. We don't want to reopen the database because we
+        // don't have main database passphrase at this point.
+        // See <https://sqlite.org/c3ref/c_dbconfig_enable_fkey.html> for documentation.
+        // Without resetting import may fail due to existing tables.
+        conn.set_db_config(DbConfig::SQLITE_DBCONFIG_RESET_DATABASE, true)
+            .context("failed to set SQLITE_DBCONFIG_RESET_DATABASE")?;
+        conn.execute("VACUUM", [])
+            .context("failed to vacuum the database")?;
+        conn.set_db_config(DbConfig::SQLITE_DBCONFIG_RESET_DATABASE, false)
+            .context("failed to unset SQLITE_DBCONFIG_RESET_DATABASE")?;
+
+        conn.execute(
+            "ATTACH DATABASE ? AS backup KEY ?",
+            paramsv![path_str, passphrase],
+        )
+        .context("failed to attach backup database")?;
+        let res = conn
+            .query_row("SELECT sqlcipher_export('main', 'backup')", [], |_row| {
+                Ok(())
+            })
+            .context("failed to import from attached backup database");
+        conn.execute("DETACH DATABASE backup", [])
+            .context("failed to detach backup database")?;
+        res?;
+        Ok(())
+    }
+
    fn new_pool(
        dbfile: &Path,
        passphrase: String,
@@ -157,6 +215,12 @@ impl Sql {
            conn.pragma_update(None, "synchronous", &"NORMAL".to_string())?;
        }

+        self.run_migrations(context).await?;
+
+        Ok(())
+    }
+
+    pub async fn run_migrations(&self, context: &Context) -> Result<()> {
        // (1) update low-level database structure.
        // this should be done before updates that use high-level objects that
        // rely themselves on the low-level structure.
@@ -231,7 +295,7 @@ impl Sql {

    /// Opens the provided database and runs any necessary migrations.
    /// If a database is already open, this will return an error.
-    pub async fn open(&self, context: &Context) -> Result<()> {
+    pub async fn open(&self, context: &Context, passphrase: String) -> Result<()> {
        if self.is_open().await {
            error!(
                context,
@@ -240,17 +304,13 @@ impl Sql {
            bail!("SQL database is already opened.");
        }

-        let passphrase_lock = self.passphrase.read().await;
-        let passphrase: &str = passphrase_lock.as_ref();
-
-        if let Err(err) = self
-            .try_open(context, &self.dbfile, passphrase.to_string())
-            .await
-        {
+        let passphrase_nonempty = !passphrase.is_empty();
+        if let Err(err) = self.try_open(context, &self.dbfile, passphrase).await {
            self.close().await;
            Err(err)
        } else {
            info!(context, "Opened database {:?}.", self.dbfile);
+            *self.is_encrypted.write().await = Some(passphrase_nonempty);
            Ok(())
        }
    }
@@ -271,10 +331,10 @@ impl Sql {
        &self,
        query: impl AsRef<str>,
        params: impl rusqlite::Params,
-    ) -> anyhow::Result<usize> {
+    ) -> Result<i64> {
        let conn = self.get_conn().await?;
        conn.execute(query.as_ref(), params)?;
-        Ok(usize::try_from(conn.last_insert_rowid())?)
+        Ok(conn.last_insert_rowid())
    }

    /// Prepares and executes the statement and maps a function over the resulting rows.
@@ -828,7 +888,7 @@ mod tests {

        t.sql.close().await;
        housekeeping(&t).await.unwrap_err(); // housekeeping should fail as the db is closed
-        t.sql.open(&t).await.unwrap();
+        t.sql.open(&t, "".to_string()).await.unwrap();

        let a = t.get_config(Config::Selfavatar).await.unwrap().unwrap();
        assert_eq!(avatar_bytes, &async_std::fs::read(&a).await.unwrap()[..]);
@@ -871,11 +931,11 @@ mod tests {
        let sql = Sql::new(dbfile.into());

        // Create database with all the tables.
-        sql.open(&t).await.unwrap();
+        sql.open(&t, "".to_string()).await.unwrap();
        sql.close().await;

        // Reopen the database
-        sql.open(&t).await?;
+        sql.open(&t, "".to_string()).await?;
        sql.execute(
            "INSERT INTO config (keyname, value) VALUES (?, ?);",
            paramsv!("foo", "bar"),
@@ -930,7 +990,7 @@ mod tests {
    }

    #[async_std::test]
-    async fn test_set_passphrase() -> Result<()> {
+    async fn test_check_passphrase() -> Result<()> {
        use tempfile::tempdir;

        // The context is used only for logging.
@@ -941,8 +1001,8 @@ mod tests {
        let dbfile = dir.path().join("testdb.sqlite");
        let sql = Sql::new(dbfile.clone().into());

-        sql.set_passphrase("foo".to_string()).await?;
-        sql.open(&t)
+        sql.check_passphrase("foo".to_string()).await?;
+        sql.open(&t, "foo".to_string())
            .await
            .context("failed to open the database first time")?;
        sql.close().await;
@@ -951,11 +1011,11 @@ mod tests {
        let sql = Sql::new(dbfile.into());

        // Test that we can't open encrypted database without a passphrase.
-        assert!(sql.open(&t).await.is_err());
+        assert!(sql.open(&t, "".to_string()).await.is_err());

-        // Now set the passphrase and open the database, it should succeed.
-        sql.set_passphrase("foo".to_string()).await?;
-        sql.open(&t)
+        // Now open the database with passpharse, it should succeed.
+        sql.check_passphrase("foo".to_string()).await?;
+        sql.open(&t, "foo".to_string())
            .await
            .context("failed to open the database second time")?;
        Ok(())
--- a/src/sql/migrations.rs
+++ b/src/sql/migrations.rs
@@ -562,6 +562,23 @@ CREATE INDEX msgs_status_updates_index1 ON msgs_status_updates (msg_id);"#,
        )
        .await?;
    }
+    if dbversion < 85 {
+        info!(context, "[migration] v85");
+        sql.execute_migration(
+            r#"CREATE TABLE smtp (
+id INTEGER PRIMARY KEY,
+rfc724_mid TEXT NOT NULL,          -- Message-ID
+mime TEXT NOT NULL,                -- SMTP payload
+msg_id INTEGER NOT NULL,           -- ID of the message in `msgs` table
+recipients TEXT NOT NULL,          -- List of recipients separated by space
+retries INTEGER NOT NULL DEFAULT 0 -- Number of failed attempts to send the messsage
+);
+CREATE INDEX smtp_messageid ON imap(rfc724_mid);
+"#,
+            85,
+        )
+        .await?;
+    }

    Ok((
        recalc_fingerprints,
--- a/src/summary.rs
+++ b/src/summary.rs
@@ -139,7 +139,10 @@ impl Message {
            }
            Viewtype::Webxdc => {
                append_text = true;
-                "Webxdc".to_string()
+                self.get_webxdc_info(context)
+                    .await
+                    .map(|info| info.name)
+                    .unwrap_or_else(|_| "ErrWebxdcName".to_string())
            }
            Viewtype::Text | Viewtype::Unknown => {
                if self.param.get_cmd() != SystemMessage::LocationOnly {
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -5,13 +5,11 @@
 use std::collections::BTreeMap;
 use std::ops::Deref;
 use std::panic;
-use std::str::FromStr;
 use std::thread;
 use std::time::{Duration, Instant};

 use ansi_term::Color;
 use async_std::channel::{self, Receiver, Sender};
-use async_std::path::PathBuf;
 use async_std::prelude::*;
 use async_std::sync::{Arc, RwLock};
 use async_std::task;
@@ -30,11 +28,9 @@ use crate::context::Context;
 use crate::dc_receive_imf::dc_receive_imf;
 use crate::dc_tools::EmailAddress;
 use crate::events::{Event, EventType};
-use crate::job::Action;
 use crate::key::{self, DcKey, KeyPair, KeyPairUse};
 use crate::message::{update_msg_state, Message, MessageState, MsgId};
 use crate::mimeparser::MimeMessage;
-use crate::param::{Param, Params};

 #[allow(non_upper_case_globals)]
 pub const AVATAR_900x900_BYTES: &[u8] = include_bytes!("../test-data/image/avatar900x900.png");
@@ -275,27 +271,27 @@ impl TestContext {
    /// Panics if there is no message or on any error.
    pub async fn pop_sent_msg(&self) -> SentMessage {
        let start = Instant::now();
-        let (rowid, foreign_id, raw_params) = loop {
+        let (rowid, msg_id, payload, recipients) = loop {
            let row = self
                .ctx
                .sql
-                .query_row(
+                .query_row_optional(
                    r#"
-                    SELECT id, foreign_id, param
-                      FROM jobs
-                     WHERE action=?
-                  ORDER BY desired_timestamp DESC;
-                "#,
-                    paramsv![Action::SendMsgToSmtp],
+                    SELECT id, msg_id, mime, recipients
+                    FROM smtp
+                    ORDER BY id DESC"#,
+                    paramsv![],
                    |row| {
-                        let id: u32 = row.get(0)?;
-                        let foreign_id: u32 = row.get(1)?;
-                        let param: String = row.get(2)?;
-                        Ok((id, foreign_id, param))
+                        let rowid: i64 = row.get(0)?;
+                        let msg_id: MsgId = row.get(1)?;
+                        let mime: String = row.get(2)?;
+                        let recipients: String = row.get(3)?;
+                        Ok((rowid, msg_id, mime, recipients))
                    },
                )
-                .await;
-            if let Ok(row) = row {
+                .await
+                .expect("query_row_optional failed");
+            if let Some(row) = row {
                break row;
            }
            if start.elapsed() < Duration::from_secs(3) {
@@ -304,26 +300,18 @@ impl TestContext {
                panic!("no sent message found in jobs table");
            }
        };
-        let id = MsgId::new(foreign_id);
-        let params = Params::from_str(&raw_params).unwrap();
-        let blob_path = params
-            .get_blob(Param::File, &self.ctx, false)
-            .await
-            .expect("failed to parse blob from param")
-            .expect("no Param::File found in Params")
-            .to_abs_path();
        self.ctx
            .sql
            .execute("DELETE FROM jobs WHERE id=?;", paramsv![rowid])
            .await
            .expect("failed to remove job");
-        update_msg_state(&self.ctx, id, MessageState::OutDelivered)
+        update_msg_state(&self.ctx, msg_id, MessageState::OutDelivered)
            .await
            .expect("failed to update message state");
        SentMessage {
-            params,
-            blob_path,
-            sender_msg_id: id,
+            payload,
+            sender_msg_id: msg_id,
+            recipients,
        }
    }

@@ -347,7 +335,7 @@ impl TestContext {
        let received_msg =
            "Received: (Postfix, from userid 1000); Mon, 4 Dec 2006 14:51:39 +0100 (CET)\n"
                .to_owned()
-                + &msg.payload();
+                + msg.payload();
        dc_receive_imf(&self.ctx, received_msg.as_bytes(), "INBOX", false)
            .await
            .unwrap();
@@ -592,8 +580,8 @@ impl Drop for LogSink {
 /// passed through a SMTP-IMAP pipeline.
 #[derive(Debug, Clone)]
 pub struct SentMessage {
-    params: Params,
-    blob_path: PathBuf,
+    payload: String,
+    recipients: String,
    pub sender_msg_id: MsgId,
 }

@@ -602,17 +590,17 @@ impl SentMessage {
    ///
    /// If there are multiple recipients this is just a random one, so is not very useful.
    pub fn recipient(&self) -> EmailAddress {
-        let raw = self
-            .params
-            .get(Param::Recipients)
-            .expect("no recipients in params");
-        let rcpt = raw.split(' ').next().expect("no recipient found");
+        let rcpt = self
+            .recipients
+            .split(' ')
+            .next()
+            .expect("no recipient found");
        rcpt.parse().expect("failed to parse email address")
    }

    /// The raw message payload.
-    pub fn payload(&self) -> String {
-        std::fs::read_to_string(&self.blob_path).unwrap()
+    pub fn payload(&self) -> &str {
+        &self.payload
    }
 }

--- a/src/webxdc.rs
+++ b/src/webxdc.rs
@@ -1,13 +1,15 @@
 //! # Handle webxdc messages.

+use crate::chat::Chat;
 use crate::constants::Viewtype;
 use crate::context::Context;
-use crate::dc_tools::dc_open_file_std;
+use crate::dc_tools::{dc_create_smeared_timestamp, dc_open_file_std};
 use crate::message::{Message, MessageState, MsgId};
 use crate::mimeparser::SystemMessage;
 use crate::param::Param;
 use crate::{chat, EventType};
 use anyhow::{bail, ensure, format_err, Result};
+use async_std::path::PathBuf;
 use lettre_email::mime::{self};
 use lettre_email::PartBuilder;
 use serde::{Deserialize, Serialize};
@@ -20,6 +22,23 @@ use zip::ZipArchive;
 pub const WEBXDC_SUFFIX: &str = "xdc";
 const WEBXDC_DEFAULT_ICON: &str = "__webxdc__/default-icon.png";

+/// Defines the maximal size in bytes of an .xdc file that can be sent.
+///
+/// We introduce a limit to force developer to create small .xdc
+/// to save user's traffic and disk space for a better ux.
+///
+/// The 100K limit should also let .xdc pass worse-quality auto-download filters
+/// which are usually 160K incl. base64 overhead.
+///
+/// The limit is also an experiment to see how small we can go;
+/// it is planned to raise that limit as needed in subsequent versions.
+const WEBXDC_SENDING_LIMIT: usize = 655360;
+
+/// Be more tolerant for .xdc sizes on receiving -
+/// might be, the senders version uses already a larger limit
+/// and not showing the .xdc on some devices would be even worse ux.
+const WEBXDC_RECEIVING_LIMIT: usize = 4194304;
+
 /// Raw information read from manifest.toml
 #[derive(Debug, Deserialize)]
 #[non_exhaustive]
@@ -32,6 +51,7 @@ struct WebxdcManifest {
 pub struct WebxdcInfo {
    pub name: String,
    pub icon: String,
+    pub summary: String,
 }

 /// Status Update ID.
@@ -71,41 +91,142 @@ struct StatusUpdates {
 #[derive(Debug, Serialize, Deserialize)]
 pub(crate) struct StatusUpdateItem {
    payload: Value,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    info: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    summary: Option<String>,
 }

 impl Context {
+    /// check if a file is an acceptable webxdc for sending or receiving.
    pub(crate) async fn is_webxdc_file(&self, filename: &str, buf: &[u8]) -> Result<bool> {
        if filename.ends_with(WEBXDC_SUFFIX) {
            let reader = std::io::Cursor::new(buf);
            if let Ok(mut archive) = zip::ZipArchive::new(reader) {
                if let Ok(_index_html) = archive.by_name("index.html") {
-                    return Ok(true);
+                    if buf.len() <= WEBXDC_RECEIVING_LIMIT {
+                        return Ok(true);
+                    } else {
+                        info!(
+                            self,
+                            "{} exceeds receiving limit of {} bytes",
+                            &filename,
+                            WEBXDC_RECEIVING_LIMIT
+                        );
+                    }
+                } else {
+                    info!(self, "{} misses index.html", &filename);
                }
+            } else {
+                info!(self, "{} cannot be opened as zip-file", &filename);
            }
        }
        Ok(false)
    }

+    /// ensure that a file is an acceptable webxdc for sending
+    /// (sending has more strict size limits).
+    pub(crate) async fn ensure_sendable_webxdc_file(&self, path: &PathBuf) -> Result<()> {
+        let mut file = std::fs::File::open(path)?;
+        let mut buf = Vec::new();
+        file.read_to_end(&mut buf)?;
+        if !self
+            .is_webxdc_file(path.to_str().unwrap_or_default(), &buf)
+            .await?
+        {
+            bail!(
+                "{} is not a valid webxdc file",
+                path.to_str().unwrap_or_default()
+            );
+        } else if buf.len() > WEBXDC_SENDING_LIMIT {
+            bail!(
+                "webxdc {} exceeds acceptable size of {} bytes",
+                path.to_str().unwrap_or_default(),
+                WEBXDC_SENDING_LIMIT
+            );
+        }
+        Ok(())
+    }
+
+    /// Takes an update-json as `{payload: PAYLOAD}` (or legacy `PAYLOAD`)
+    /// writes it to the database and handles events, info-messages and summary.
    async fn create_status_update_record(
        &self,
-        instance_msg_id: MsgId,
-        payload: &str,
+        instance: &mut Message,
+        update_str: &str,
+        timestamp: i64,
    ) -> Result<StatusUpdateId> {
-        let payload = payload.trim();
-        if payload.is_empty() {
-            bail!("create_status_update_record: empty payload");
+        let update_str = update_str.trim();
+        if update_str.is_empty() {
+            bail!("create_status_update_record: empty update.");
+        }
+
+        let status_update_item: StatusUpdateItem = {
+            if let Ok(item) = serde_json::from_str::<StatusUpdateItem>(update_str) {
+                match instance.state {
+                    MessageState::Undefined
+                    | MessageState::OutPreparing
+                    | MessageState::OutDraft => StatusUpdateItem {
+                        payload: item.payload,
+                        info: None, // no info-messages in draft mode
+                        summary: item.summary,
+                    },
+                    _ => item,
+                }
+            } else {
+                // TODO: this fallback (legacy `PAYLOAD`) should be deleted soon, together with the test below
+                let payload: Value = serde_json::from_str(update_str)?; // checks if input data are valid json
+                StatusUpdateItem {
+                    payload,
+                    info: None,
+                    summary: None,
+                }
+            }
+        };
+
+        if let Some(ref info) = status_update_item.info {
+            chat::add_info_msg_with_cmd(
+                self,
+                instance.chat_id,
+                info.as_str(),
+                SystemMessage::Unknown,
+                timestamp,
+                Some(instance),
+            )
+            .await?;
+        }
+
+        if let Some(ref summary) = status_update_item.summary {
+            if instance
+                .param
+                .update_timestamp(Param::WebxdcSummaryTimestamp, timestamp)?
+            {
+                instance.param.set(Param::WebxdcSummary, summary);
+                instance.update_param(self).await;
+                self.emit_event(EventType::MsgsChanged {
+                    chat_id: instance.chat_id,
+                    msg_id: instance.id,
+                });
+            }
        }
-        let payload: Value = serde_json::from_str(payload)?; // checks if input data are valid json
-        let status_update_item = StatusUpdateItem { payload };

        let rowid = self
            .sql
            .insert(
                "INSERT INTO msgs_status_updates (msg_id, update_item) VALUES(?, ?);",
-                paramsv![instance_msg_id, serde_json::to_string(&status_update_item)?],
+                paramsv![instance.id, serde_json::to_string(&status_update_item)?],
            )
            .await?;
-        Ok(StatusUpdateId(u32::try_from(rowid)?))
+        let status_update_id = StatusUpdateId(u32::try_from(rowid)?);
+
+        self.emit_event(EventType::WebxdcStatusUpdate {
+            msg_id: instance.id,
+            status_update_id,
+        });
+
+        Ok(status_update_id)
    }

    /// Sends a status update for an webxdc instance.
@@ -118,21 +239,24 @@ impl Context {
    pub async fn send_webxdc_status_update(
        &self,
        instance_msg_id: MsgId,
-        payload: &str,
+        update_str: &str,
        descr: &str,
    ) -> Result<Option<MsgId>> {
-        let instance = Message::load_from_db(self, instance_msg_id).await?;
+        let mut instance = Message::load_from_db(self, instance_msg_id).await?;
        if instance.viewtype != Viewtype::Webxdc {
            bail!("send_webxdc_status_update: is no webxdc message");
        }

+        let chat = Chat::load_from_db(self, instance.chat_id).await?;
+        ensure!(chat.can_send(self).await?, "cannot send to {}", chat.id);
+
        let status_update_id = self
-            .create_status_update_record(instance_msg_id, payload)
+            .create_status_update_record(
+                &mut instance,
+                update_str,
+                dc_create_smeared_timestamp(self).await,
+            )
            .await?;
-        self.emit_event(EventType::WebxdcStatusUpdate {
-            msg_id: instance_msg_id,
-            status_update_id,
-        });
        match instance.state {
            MessageState::Undefined | MessageState::OutPreparing | MessageState::OutDraft => {
                // send update once the instance is actually send
@@ -161,6 +285,7 @@ impl Context {
                    .ok_or_else(|| format_err!("Status object expected."))?,
                );
                status_update.set_quote(self, Some(&instance)).await?;
+                status_update.param.remove(Param::GuaranteeE2ee); // may be set by set_quote(), if #2985 is done, this line can be removed
                let status_update_msg_id =
                    chat::send_msg(self, instance.chat_id, &mut status_update).await?;
                Ok(Some(status_update_msg_id))
@@ -188,11 +313,11 @@ impl Context {
    /// the array is parsed using serde, the single payloads are used as is.
    pub(crate) async fn receive_status_update(&self, msg_id: MsgId, json: &str) -> Result<()> {
        let msg = Message::load_from_db(self, msg_id).await?;
-        let instance = if msg.viewtype == Viewtype::Webxdc {
-            msg
+        let (timestamp, mut instance) = if msg.viewtype == Viewtype::Webxdc {
+            (msg.timestamp_sort, msg)
        } else if let Some(parent) = msg.parent(self).await? {
            if parent.viewtype == Viewtype::Webxdc {
-                parent
+                (msg.timestamp_sort, parent)
            } else {
                bail!("receive_status_update: message is not the child of a webxdc message.")
            }
@@ -202,16 +327,12 @@ impl Context {

        let updates: StatusUpdates = serde_json::from_str(json)?;
        for update_item in updates.updates {
-            let status_update_id = self
-                .create_status_update_record(
-                    instance.id,
-                    &*serde_json::to_string(&update_item.payload)?,
-                )
-                .await?;
-            self.emit_event(EventType::WebxdcStatusUpdate {
-                msg_id: instance.id,
-                status_update_id,
-            });
+            self.create_status_update_record(
+                &mut instance,
+                &*serde_json::to_string(&update_item)?,
+                timestamp,
+            )
+            .await?;
        }

        Ok(())
@@ -351,6 +472,11 @@ impl Message {
            } else {
                WEBXDC_DEFAULT_ICON.to_string()
            },
+            summary: self
+                .param
+                .get(Param::WebxdcSummary)
+                .unwrap_or_default()
+                .to_string(),
        })
    }
 }
@@ -358,12 +484,27 @@ impl Message {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::chat::{create_group_chat, send_msg, send_text_msg, ChatId, ProtectionStatus};
+    use crate::chat::{
+        add_contact_to_chat, create_group_chat, forward_msgs, send_msg, send_text_msg, ChatId,
+        ProtectionStatus,
+    };
+    use crate::chatlist::Chatlist;
+    use crate::contact::Contact;
    use crate::dc_receive_imf::dc_receive_imf;
    use crate::test_utils::TestContext;
    use async_std::fs::File;
    use async_std::io::WriteExt;

+    #[allow(clippy::assertions_on_constants)]
+    #[async_std::test]
+    async fn test_webxdc_file_limits() -> Result<()> {
+        assert!(WEBXDC_SENDING_LIMIT >= 32768);
+        assert!(WEBXDC_SENDING_LIMIT < 16777216);
+        assert!(WEBXDC_RECEIVING_LIMIT >= WEBXDC_SENDING_LIMIT * 2);
+        assert!(WEBXDC_RECEIVING_LIMIT < 16777216);
+        Ok(())
+    }
+
    #[async_std::test]
    async fn test_is_webxdc_file() -> Result<()> {
        let t = TestContext::new().await;
@@ -421,6 +562,7 @@ mod tests {
        )
        .await?;
        let instance_msg_id = send_msg(t, chat_id, &mut instance).await?;
+        assert_eq!(instance.viewtype, Viewtype::Webxdc);
        Message::load_from_db(t, instance_msg_id).await
    }

@@ -448,6 +590,76 @@ mod tests {
        Ok(())
    }

+    #[async_std::test]
+    async fn test_send_invalid_webxdc() -> Result<()> {
+        let t = TestContext::new_alice().await;
+        let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "foo").await?;
+
+        // sending invalid .xdc as file is possible, but must not result in Viewtype::Webxdc
+        let mut instance = create_webxdc_instance(
+            &t,
+            "invalid-no-zip-but-7z.xdc",
+            include_bytes!("../test-data/webxdc/invalid-no-zip-but-7z.xdc"),
+        )
+        .await?;
+        let instance_id = send_msg(&t, chat_id, &mut instance).await?;
+        assert_eq!(instance.viewtype, Viewtype::File);
+        let test = Message::load_from_db(&t, instance_id).await?;
+        assert_eq!(test.viewtype, Viewtype::File);
+
+        // sending invalid .xdc as Viewtype::Webxdc should fail already on sending
+        let file = t.get_blobdir().join("invalid2.xdc");
+        File::create(&file)
+            .await?
+            .write_all(include_bytes!(
+                "../test-data/webxdc/invalid-no-zip-but-7z.xdc"
+            ))
+            .await?;
+        let mut instance = Message::new(Viewtype::Webxdc);
+        instance.set_file(file.to_str().unwrap(), None);
+        assert!(send_msg(&t, chat_id, &mut instance).await.is_err());
+
+        Ok(())
+    }
+
+    #[async_std::test]
+    async fn test_forward_webxdc_instance() -> Result<()> {
+        let t = TestContext::new_alice().await;
+        let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "foo").await?;
+        let instance = send_webxdc_instance(&t, chat_id).await?;
+        t.send_webxdc_status_update(
+            instance.id,
+            r#"{"info": "foo", "summary":"bar", "payload": 42}"#,
+            "descr",
+        )
+        .await?;
+        assert!(!instance.is_forwarded());
+        assert_eq!(
+            t.get_webxdc_status_updates(instance.id, None).await?,
+            r#"[{"payload":42,"info":"foo","summary":"bar"}]"#
+        );
+        assert_eq!(chat_id.get_msg_cnt(&t).await?, 2); // instance and info
+        let info = Message::load_from_db(&t, instance.id)
+            .await?
+            .get_webxdc_info(&t)
+            .await?;
+        assert_eq!(info.summary, "bar".to_string());
+
+        // forwarding an instance creates a fresh instance; updates etc. are not forwarded
+        forward_msgs(&t, &[instance.get_id()], chat_id).await?;
+        let instance2 = t.get_last_msg_in(chat_id).await;
+        assert!(instance2.is_forwarded());
+        assert_eq!(t.get_webxdc_status_updates(instance2.id, None).await?, "[]");
+        assert_eq!(chat_id.get_msg_cnt(&t).await?, 3); // two instances, only one info
+        let info = Message::load_from_db(&t, instance2.id)
+            .await?
+            .get_webxdc_info(&t)
+            .await?;
+        assert_eq!(info.summary, "".to_string());
+
+        Ok(())
+    }
+
    #[async_std::test]
    async fn test_receive_webxdc_instance() -> Result<()> {
        let t = TestContext::new_alice().await;
@@ -476,6 +688,48 @@ mod tests {
        Ok(())
    }

+    #[async_std::test]
+    async fn test_webxdc_contact_request() -> Result<()> {
+        let alice = TestContext::new_alice().await;
+        let bob = TestContext::new_bob().await;
+
+        // Alice sends an webxdc instance to Bob
+        let alice_chat = alice.create_chat(&bob).await;
+        let _alice_instance = send_webxdc_instance(&alice, alice_chat.id).await?;
+        bob.recv_msg(&alice.pop_sent_msg().await).await;
+
+        // Bob can start the webxdc from a contact request (get index.html)
+        // but cannot send updates to contact requests
+        let bob_instance = bob.get_last_msg().await;
+        let bob_chat = Chat::load_from_db(&bob, bob_instance.chat_id).await?;
+        assert!(bob_chat.is_contact_request());
+        assert!(bob_instance
+            .get_webxdc_blob(&bob, "index.html")
+            .await
+            .is_ok());
+        assert!(bob
+            .send_webxdc_status_update(bob_instance.id, r#"{"payload":42}"#, "descr")
+            .await
+            .is_err());
+        assert_eq!(
+            bob.get_webxdc_status_updates(bob_instance.id, None).await?,
+            "[]"
+        );
+
+        // Once the contact request is accepted, Bob can send updates
+        bob_chat.id.accept(&bob).await?;
+        assert!(bob
+            .send_webxdc_status_update(bob_instance.id, r#"{"payload":42}"#, "descr")
+            .await
+            .is_ok());
+        assert_eq!(
+            bob.get_webxdc_status_updates(bob_instance.id, None).await?,
+            r#"[{"payload":42}]"#
+        );
+
+        Ok(())
+    }
+
    #[async_std::test]
    async fn test_delete_webxdc_instance() -> Result<()> {
        let t = TestContext::new_alice().await;
@@ -489,7 +743,7 @@ mod tests {
        .await?;
        chat_id.set_draft(&t, Some(&mut instance)).await?;
        let instance = chat_id.get_draft(&t).await?.unwrap();
-        t.send_webxdc_status_update(instance.id, "42", "descr")
+        t.send_webxdc_status_update(instance.id, r#"{"payload": 42}"#, "descr")
            .await?;
        assert_eq!(
            t.get_webxdc_status_updates(instance.id, None).await?,
@@ -516,12 +770,16 @@ mod tests {
    async fn test_create_status_update_record() -> Result<()> {
        let t = TestContext::new_alice().await;
        let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "foo").await?;
-        let instance = send_webxdc_instance(&t, chat_id).await?;
+        let mut instance = send_webxdc_instance(&t, chat_id).await?;

        assert_eq!(t.get_webxdc_status_updates(instance.id, None).await?, "[]");

        let id = t
-            .create_status_update_record(instance.id, "\n\n{\"foo\":\"bar\"}\n")
+            .create_status_update_record(
+                &mut instance,
+                "\n\n{\"payload\": {\"foo\":\"bar\"}}\n",
+                1640178619,
+            )
            .await?;
        assert_eq!(
            t.get_webxdc_status_updates(instance.id, Some(id)).await?,
@@ -529,11 +787,11 @@ mod tests {
        );

        assert!(t
-            .create_status_update_record(instance.id, "\n\n\n")
+            .create_status_update_record(&mut instance, "\n\n\n", 1640178619)
            .await
            .is_err());
        assert!(t
-            .create_status_update_record(instance.id, "bad json")
+            .create_status_update_record(&mut instance, "bad json", 1640178619)
            .await
            .is_err());
        assert_eq!(
@@ -546,13 +804,18 @@ mod tests {
        );

        let id = t
-            .create_status_update_record(instance.id, r#"{"foo2":"bar2"}"#)
+            .create_status_update_record(
+                &mut instance,
+                r#"{"payload" : { "foo2":"bar2"}}"#,
+                1640178619,
+            )
            .await?;
        assert_eq!(
            t.get_webxdc_status_updates(instance.id, Some(id)).await?,
            r#"[{"payload":{"foo2":"bar2"}}]"#
        );
-        t.create_status_update_record(instance.id, "true").await?;
+        t.create_status_update_record(&mut instance, r#"{"payload":true}"#, 1640178619)
+            .await?;
        assert_eq!(
            t.get_webxdc_status_updates(instance.id, None).await?,
            r#"[{"payload":{"foo":"bar"}},
@@ -560,6 +823,27 @@ mod tests {
 {"payload":true}]"#
        );

+        let id = t
+            .create_status_update_record(
+                &mut instance,
+                r#"{"payload" : 1, "sender": "that is not used"}"#,
+                1640178619,
+            )
+            .await?;
+        assert_eq!(
+            t.get_webxdc_status_updates(instance.id, Some(id)).await?,
+            r#"[{"payload":1}]"#
+        );
+
+        // TODO: legacy `PAYLOAD` support should be deleted soon
+        let id = t
+            .create_status_update_record(&mut instance, r#"{"foo" : 1}"#, 1640178619)
+            .await?;
+        assert_eq!(
+            t.get_webxdc_status_updates(instance.id, Some(id)).await?,
+            r#"[{"payload":{"foo":1}}]"#
+        );
+
        Ok(())
    }

@@ -656,7 +940,11 @@ mod tests {
        assert!(!sent1.payload().contains("report-type=status-update"));

        let status_update_msg_id = alice
-            .send_webxdc_status_update(alice_instance.id, r#"{"foo":"bar"}"#, "descr text")
+            .send_webxdc_status_update(
+                alice_instance.id,
+                r#"{"payload" : {"foo":"bar"}}"#,
+                "descr text",
+            )
            .await?
            .unwrap();
        expect_status_update_event(&alice, alice_instance.id).await?;
@@ -682,7 +970,11 @@ mod tests {
        );

        alice
-            .send_webxdc_status_update(alice_instance.id, r#"{"snipp":"snapp"}"#, "bla text")
+            .send_webxdc_status_update(
+                alice_instance.id,
+                r#"{"payload":{"snipp":"snapp"}}"#,
+                "bla text",
+            )
            .await?
            .unwrap();
        assert_eq!(
@@ -738,7 +1030,8 @@ mod tests {
            .await?
            .is_none());

-        t.send_webxdc_status_update(instance.id, "1", "bla").await?;
+        t.send_webxdc_status_update(instance.id, r#"{"payload": 1}"#, "bla")
+            .await?;
        assert!(t
            .render_webxdc_status_update_object(instance.id, None)
            .await?
@@ -767,14 +1060,15 @@ mod tests {
        let mut alice_instance = alice_chat_id.get_draft(&alice).await?.unwrap();

        let status_update_msg_id = alice
-            .send_webxdc_status_update(alice_instance.id, r#"{"foo":"bar"}"#, "descr")
+            .send_webxdc_status_update(alice_instance.id, r#"{"payload": {"foo":"bar"}}"#, "descr")
            .await?;
        assert_eq!(status_update_msg_id, None);
        expect_status_update_event(&alice, alice_instance.id).await?;
        let status_update_msg_id = alice
-            .send_webxdc_status_update(alice_instance.id, r#"42"#, "descr")
+            .send_webxdc_status_update(alice_instance.id, r#"{"payload":42, "info":"i"}"#, "descr")
            .await?;
        assert_eq!(status_update_msg_id, None);
+        assert!(!alice.get_last_msg().await.is_info()); // 'info: "i"' message not added in draft mode

        // send webxdc instance,
        // the initial status updates are sent together in the same message
@@ -799,7 +1093,7 @@ mod tests {
        assert_eq!(
            bob.get_webxdc_status_updates(bob_instance.id, None).await?,
            r#"[{"payload":{"foo":"bar"}},
-{"payload":42}]"#
+{"payload":42}]"# // 'info: "i"' ignored as sent in draft mode
        );

        Ok(())
@@ -1017,4 +1311,267 @@ sth_for_the = "future""#

        Ok(())
    }
+
+    #[async_std::test]
+    async fn test_webxdc_info_summary() -> Result<()> {
+        let alice = TestContext::new_alice().await;
+        let bob = TestContext::new_bob().await;
+
+        // Alice creates an webxdc instance and updates summary
+        let alice_chat = alice.create_chat(&bob).await;
+        let alice_instance = send_webxdc_instance(&alice, alice_chat.id).await?;
+        let sent_instance = &alice.pop_sent_msg().await;
+        let info = alice_instance.get_webxdc_info(&alice).await?;
+        assert_eq!(info.summary, "".to_string());
+
+        alice
+            .send_webxdc_status_update(
+                alice_instance.id,
+                r#"{"summary":"sum: 1", "payload":1}"#,
+                "descr",
+            )
+            .await?;
+        let sent_update1 = &alice.pop_sent_msg().await;
+        let info = Message::load_from_db(&alice, alice_instance.id)
+            .await?
+            .get_webxdc_info(&alice)
+            .await?;
+        assert_eq!(info.summary, "sum: 1".to_string());
+
+        alice
+            .send_webxdc_status_update(
+                alice_instance.id,
+                r#"{"summary":"sum: 2", "payload":2}"#,
+                "descr",
+            )
+            .await?;
+        let sent_update2 = &alice.pop_sent_msg().await;
+        let info = Message::load_from_db(&alice, alice_instance.id)
+            .await?
+            .get_webxdc_info(&alice)
+            .await?;
+        assert_eq!(info.summary, "sum: 2".to_string());
+
+        // Bob receives the updates
+        bob.recv_msg(sent_instance).await;
+        let bob_instance = bob.get_last_msg().await;
+        bob.recv_msg(sent_update1).await;
+        bob.recv_msg(sent_update2).await;
+        let info = Message::load_from_db(&bob, bob_instance.id)
+            .await?
+            .get_webxdc_info(&bob)
+            .await?;
+        assert_eq!(info.summary, "sum: 2".to_string());
+
+        // Alice has a second device and also receives the updates there
+        let alice2 = TestContext::new_alice().await;
+        alice2.recv_msg(sent_instance).await;
+        let alice2_instance = alice2.get_last_msg().await;
+        alice2.recv_msg(sent_update1).await;
+        alice2.recv_msg(sent_update2).await;
+        let info = Message::load_from_db(&alice2, alice2_instance.id)
+            .await?
+            .get_webxdc_info(&alice2)
+            .await?;
+        assert_eq!(info.summary, "sum: 2".to_string());
+
+        Ok(())
+    }
+
+    #[async_std::test]
+    async fn test_webxdc_info_msg() -> Result<()> {
+        let alice = TestContext::new_alice().await;
+        let bob = TestContext::new_bob().await;
+
+        // Alice sends update with an info message
+        let alice_chat = alice.create_chat(&bob).await;
+        let alice_instance = send_webxdc_instance(&alice, alice_chat.id).await?;
+        let sent1 = &alice.pop_sent_msg().await;
+        assert_eq!(alice_chat.id.get_msg_cnt(&alice).await?, 1);
+
+        alice
+            .send_webxdc_status_update(
+                alice_instance.id,
+                r#"{"info":"this appears in-chat", "payload":"sth. else"}"#,
+                "descr text",
+            )
+            .await?;
+        let sent2 = &alice.pop_sent_msg().await;
+        assert_eq!(alice_chat.id.get_msg_cnt(&alice).await?, 2);
+        let info_msg = alice.get_last_msg().await;
+        assert!(info_msg.is_info());
+        assert_eq!(
+            info_msg.get_text(),
+            Some("this appears in-chat".to_string())
+        );
+        assert_eq!(
+            info_msg.parent(&alice).await?.unwrap().id,
+            alice_instance.id
+        );
+        assert!(info_msg.quoted_message(&alice).await?.is_none());
+        assert_eq!(
+            alice
+                .get_webxdc_status_updates(alice_instance.id, None)
+                .await?,
+            r#"[{"payload":"sth. else","info":"this appears in-chat"}]"#
+        );
+
+        // Bob receives all messages
+        bob.recv_msg(sent1).await;
+        let bob_instance = bob.get_last_msg().await;
+        let bob_chat_id = bob_instance.chat_id;
+        bob.recv_msg(sent2).await;
+        assert_eq!(bob_chat_id.get_msg_cnt(&bob).await?, 2);
+        let info_msg = bob.get_last_msg().await;
+        assert!(info_msg.is_info());
+        assert_eq!(
+            info_msg.get_text(),
+            Some("this appears in-chat".to_string())
+        );
+        assert_eq!(info_msg.parent(&bob).await?.unwrap().id, bob_instance.id);
+        assert!(info_msg.quoted_message(&bob).await?.is_none());
+        assert_eq!(
+            bob.get_webxdc_status_updates(bob_instance.id, None).await?,
+            r#"[{"payload":"sth. else","info":"this appears in-chat"}]"#
+        );
+
+        // Alice has a second device and also receives the info message there
+        let alice2 = TestContext::new_alice().await;
+        alice2.recv_msg(sent1).await;
+        let alice2_instance = alice2.get_last_msg().await;
+        let alice2_chat_id = alice2_instance.chat_id;
+        alice2.recv_msg(sent2).await;
+        assert_eq!(alice2_chat_id.get_msg_cnt(&alice2).await?, 2);
+        let info_msg = alice2.get_last_msg().await;
+        assert!(info_msg.is_info());
+        assert_eq!(
+            info_msg.get_text(),
+            Some("this appears in-chat".to_string())
+        );
+        assert_eq!(
+            info_msg.parent(&alice2).await?.unwrap().id,
+            alice2_instance.id
+        );
+        assert!(info_msg.quoted_message(&alice2).await?.is_none());
+        assert_eq!(
+            alice2
+                .get_webxdc_status_updates(alice2_instance.id, None)
+                .await?,
+            r#"[{"payload":"sth. else","info":"this appears in-chat"}]"#
+        );
+
+        Ok(())
+    }
+
+    #[async_std::test]
+    async fn test_webxdc_opportunistic_encryption() -> Result<()> {
+        let alice = TestContext::new_alice().await;
+        let bob = TestContext::new_bob().await;
+
+        // Bob sends sth. to Alice, Alice has Bob's key
+        let bob_chat_id = create_group_chat(&bob, ProtectionStatus::Unprotected, "chat").await?;
+        add_contact_to_chat(
+            &bob,
+            bob_chat_id,
+            Contact::create(&bob, "", "alice@example.org").await?,
+        )
+        .await?;
+        send_text_msg(&bob, bob_chat_id, "populate".to_string()).await?;
+        alice.recv_msg(&bob.pop_sent_msg().await).await;
+
+        // Alice sends instance+update to Bob
+        let alice_chat_id = alice.get_last_msg().await.chat_id;
+        alice_chat_id.accept(&alice).await?;
+        let alice_instance = send_webxdc_instance(&alice, alice_chat_id).await?;
+        let sent1 = &alice.pop_sent_msg().await;
+        let update_msg_id = alice
+            .send_webxdc_status_update(alice_instance.id, r#"{"payload":42}"#, "descr")
+            .await?
+            .unwrap();
+        let update_msg = Message::load_from_db(&alice, update_msg_id).await?;
+        let sent2 = &alice.pop_sent_msg().await;
+        assert!(alice_instance.get_showpadlock());
+        assert!(update_msg.get_showpadlock());
+
+        // Bob receives instance+update
+        bob.recv_msg(sent1).await;
+        let bob_instance = bob.get_last_msg().await;
+        bob.recv_msg(sent2).await;
+        assert!(bob_instance.get_showpadlock());
+
+        // Bob adds Claire with unknown key, update to Alice+Claire cannot be encrypted
+        add_contact_to_chat(
+            &bob,
+            bob_chat_id,
+            Contact::create(&bob, "", "claire@example.org").await?,
+        )
+        .await?;
+        let update_msg_id = bob
+            .send_webxdc_status_update(bob_instance.id, r#"{"payload":43}"#, "descr")
+            .await?
+            .unwrap();
+        let update_msg = Message::load_from_db(&bob, update_msg_id).await?;
+        assert!(!update_msg.get_showpadlock());
+
+        Ok(())
+    }
+
+    #[async_std::test]
+    async fn test_webxdc_chatlist_summary() -> Result<()> {
+        let t = TestContext::new_alice().await;
+        let chat_id = create_group_chat(&t, ProtectionStatus::Unprotected, "chat").await?;
+        let mut instance = create_webxdc_instance(
+            &t,
+            "with-minimal-manifest.xdc",
+            include_bytes!("../test-data/webxdc/with-minimal-manifest.xdc"),
+        )
+        .await?;
+        send_msg(&t, chat_id, &mut instance).await?;
+
+        let chatlist = Chatlist::try_load(&t, 0, None, None).await?;
+        assert_eq!(chatlist.len(), 1);
+        let summary = chatlist.get_summary(&t, 0, None).await?;
+        assert_eq!(summary.text, "nice app!".to_string());
+
+        Ok(())
+    }
+
+    #[async_std::test]
+    async fn test_webxdc_and_text() -> Result<()> {
+        let alice = TestContext::new_alice().await;
+        let bob = TestContext::new_bob().await;
+
+        // Alice sends instance and adds some text
+        let alice_chat = alice.create_chat(&bob).await;
+        let mut alice_instance = create_webxdc_instance(
+            &alice,
+            "minimal.xdc",
+            include_bytes!("../test-data/webxdc/minimal.xdc"),
+        )
+        .await?;
+        alice_instance.set_text(Some("user added text".to_string()));
+        send_msg(&alice, alice_chat.id, &mut alice_instance).await?;
+        let alice_instance = alice.get_last_msg().await;
+        assert_eq!(
+            alice_instance.get_text(),
+            Some("user added text".to_string())
+        );
+
+        // Bob receives that instance
+        let sent1 = alice.pop_sent_msg().await;
+        bob.recv_msg(&sent1).await;
+        let bob_instance = bob.get_last_msg().await;
+        assert_eq!(bob_instance.get_text(), Some("user added text".to_string()));
+
+        // Alice's second device receives the instance as well
+        let alice2 = TestContext::new_alice().await;
+        alice2.recv_msg(&sent1).await;
+        let alice2_instance = alice2.get_last_msg().await;
+        assert_eq!(
+            alice2_instance.get_text(),
+            Some("user added text".to_string())
+        );
+
+        Ok(())
+    }
 }
--- a/standards.md
+++ b/standards.md
@@ -15,6 +15,7 @@ Quota                            | IMAP QUOTA extension ([RFC 2087](https://tool
 Seen status synchronization      | IMAP CONDSTORE extension ([RFC 7162](https://tools.ietf.org/html/rfc7162))
 Authorization                    | OAuth2 ([RFC 6749](https://tools.ietf.org/html/rfc6749))
 End-to-end encryption            | [Autocrypt Level 1](https://autocrypt.org/level1.html), OpenPGP ([RFC 4880](https://tools.ietf.org/html/rfc4880)), Security Multiparts for MIME ([RFC 1847](https://tools.ietf.org/html/rfc1847)) and [“Mixed Up” Encryption repairing](https://tools.ietf.org/id/draft-dkg-openpgp-pgpmime-message-mangling-00.html)
+Header encryption                | [Protected Headers for Cryptographic E-mail](https://datatracker.ietf.org/doc/draft-autocrypt-lamps-protected-headers/)
 Configuration assistance         | [Autoconfigure](https://developer.mozilla.org/en-US/docs/Mozilla/Thunderbird/Autoconfiguration) and [Autodiscover](https://technet.microsoft.com/library/bb124251(v=exchg.150).aspx)
 Messenger functions              | [Chat-over-Email](https://github.com/deltachat/deltachat-core-rust/blob/master/spec.md#chat-mail-specification)
 Detect mailing list              | List-Id ([RFC 2919](https://tools.ietf.org/html/rfc2919)) and Precedence ([RFC 3834](https://tools.ietf.org/html/rfc3834))
--- a/test-data/webxdc/invalid-no-zip-but-7z.xdc
+++ b/test-data/webxdc/invalid-no-zip-but-7z.xdc
Author	SHA1	Message	Date
bjoern	a43fc47bb6	update provider database (#3043 ) * update provider database ran `./src/provider/update.py ../provider-db/_providers/ > src/provider/data.rs` * update changelog	2022-01-31 16:07:20 +01:00
bjoern	8c1bfac53b	prepare 1.73 (#3042 ) * update changelog for 1.73.0 * bump version to 1.73.0	2022-01-31 15:12:44 +01:00
Floris Bruynooghe	97853c3660	Flub/watch mvbox only (#3028 ) * Make set_config() look a bit nicer * Add OnlyFetchMvbox option * Add test for the config * Add option to only watch mvbox This is supposed to support having a server-side rule which moves emails to the mvbox already. The new option makes sure the mvbox is wathched and also makes sure no messages are feched from folders other than the mvbox and the spam folder if enabled. It does not interact with the other settings. * Fixup ignore conditions * Cleanup some bits * Watch the mvbox when `WatchMvboxOnly` is set * Rename back to only_fetch_mvbox (flub said it's OK for him) * typo * clippy, more typos Co-authored-by: Hocuri <hocuri@gmx.de>	2022-01-31 13:39:48 +01:00
link2xt	f304a30193	imap: fetch Inbox before scanning other folders	2022-01-31 12:03:21 +01:00
link2xt	7eadca3959	imap: do not synchronize Seen flags on unwatched folders Synchronizing seen flags doubles the time required to scan all folders. Delta Chat only marks messages as Seen on Inbox or DeltaChat, so there is no need to check for Seen flag on other folders.	2022-01-30 20:00:00 +00:00
link2xt	8aa6decbf9	imap: call delete_expired_imap_messages() less often This operation takes roughly 0.3 s on a moderate size database. Calling it once before scanning all folders and scanning the watched folder instead of each time after downloading a message from a folder speeds up IMAP loop.	2022-01-30 20:49:32 +00:00
link2xt	7cf4bcaca2	imap: call delete_expired_imap_messages() less often This operation takes roughly 0.3 s on a moderate size database. Calling it once before scanning all folders and scanning the watched folder instead of each time after downloading a message from a folder speeds up IMAP loop.	2022-01-30 20:47:32 +00:00
dependabot[bot]	9ccd9c3e0e	Merge pull request #3011 from deltachat/dependabot/cargo/serde-1.0.136	2022-01-30 20:13:39 +00:00
dependabot[bot]	c6773a6303	Merge pull request #3020 from deltachat/dependabot/cargo/backtrace-0.3.64	2022-01-30 20:13:20 +00:00
link2xt	e858a32aa1	smtp: cancel message sending by removing the message This restores the logic removed in `afd8c0d879`	2022-01-30 10:59:10 +00:00
B. Petersen	99f2680e2c	fix splitting off text from webxdc messages moreover, make the split check exhaustive to avoid the same error on the next added Viewtype.	2022-01-30 11:49:09 +01:00
B. Petersen	7a9a323bac	test sending webxdc+text	2022-01-30 11:49:09 +01:00
dependabot[bot]	62aa234352	cargo: bump backtrace from 0.3.63 to 0.3.64 Bumps [backtrace](https://github.com/rust-lang/backtrace-rs) from 0.3.63 to 0.3.64. - [Release notes](https://github.com/rust-lang/backtrace-rs/releases) - [Commits](https://github.com/rust-lang/backtrace-rs/compare/0.3.63...0.3.64) --- updated-dependencies: - dependency-name: backtrace dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com>	2022-01-30 09:54:28 +00:00
link2xt	0cb9e7922a	Remove direct dependency on byteorder crate	2022-01-29 23:24:25 +00:00
link2xt	e73107006e	smtp: replace thiserror with anyhow	2022-01-29 16:41:47 +00:00
link2xt	ca389cc6fc	Move webxdc change to Unreleased	2022-01-29 16:41:04 +00:00
link2xt	60ec7f0cbf	Move last changelog entry to Unreleased	2022-01-29 16:39:28 +00:00
B. Petersen	d342d59e65	use webxdc app name in chatlist/quotes/replies/etc this uses `get_webxdc_info().name` for chatlist etc. the previuosly used static strings comes from a time where we just did not had the correct name. i was also thinking about adding `get_webxdc_info().summary`, however, as this information is dynamic, that may open several issues, eg. quoted text may change so that the answer is out of context.	2022-01-29 16:48:24 +01:00
link2xt	2690fa2da5	Don't watch Sent folder by default	2022-01-29 11:35:02 +00:00
B. Petersen	e411c394ca	add a link to search for #webxdc on github to the webxdc-docs	2022-01-29 00:42:56 +01:00
B. Petersen	d69f3ba225	adapt draft to new api	2022-01-28 21:10:34 +01:00
B. Petersen	739807b1a9	add links to webxdc development tool, simulator and to advanced examples	2022-01-28 17:42:32 +01:00
dependabot[bot]	d029ea7f3f	cargo: bump mailparse from 0.13.7 to 0.13.8 Bumps [mailparse](https://github.com/staktrace/mailparse) from 0.13.7 to 0.13.8. - [Release notes](https://github.com/staktrace/mailparse/releases) - [Commits](https://github.com/staktrace/mailparse/compare/v0.13.7...v0.13.8) --- updated-dependencies: - dependency-name: mailparse dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com>	2022-01-27 21:27:05 +01:00
dependabot[bot]	11098cb869	cargo: bump libc from 0.2.113 to 0.2.114 Bumps [libc](https://github.com/rust-lang/libc) from 0.2.113 to 0.2.114. - [Release notes](https://github.com/rust-lang/libc/releases) - [Commits](https://github.com/rust-lang/libc/compare/0.2.113...0.2.114) --- updated-dependencies: - dependency-name: libc dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com>	2022-01-27 21:26:23 +01:00
Hocuri	f6807d6b22	Fix set_config_bool() (#3013 )	2022-01-27 12:12:16 +01:00
dependabot[bot]	7fc9bacf54	cargo: bump serde from 1.0.135 to 1.0.136 Bumps [serde](https://github.com/serde-rs/serde) from 1.0.135 to 1.0.136. - [Release notes](https://github.com/serde-rs/serde/releases) - [Commits](https://github.com/serde-rs/serde/compare/v1.0.135...v1.0.136) --- updated-dependencies: - dependency-name: serde dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com>	2022-01-26 21:14:08 +00:00
B. Petersen	57ea4c1d92	bump version to 1.72.0	2022-01-25 18:18:18 +01:00
B. Petersen	bcdd15ef3a	update changelog for 1.72.0	2022-01-25 18:18:18 +01:00
Hocuri	5f939c3123	Fix: Run migrations after importing backup again (#3006 ) As of #2980, the migrations were not run after importing a backup. This lead to errors like "Failed to send message: no such table: smtp" if you imported a backup from a previous DC version.	2022-01-24 18:36:28 +03:00
B. Petersen	2446fc44ad	fix typo in mergeable description	2022-01-24 13:19:20 +01:00
dependabot[bot]	9ba8dd91df	Merge pull request #2990 from deltachat/dependabot/cargo/stop-token-0.7.0	2022-01-23 21:23:56 +00:00
B. Petersen	10e1cdbc52	bump version to 1.71.0	2022-01-23 20:58:49 +01:00
B. Petersen	46eceb38d5	update changelog for 1.71.0 as we had the changelog-chat only in the last days, - add missing pr - update some wrong references - unify some layout and wordings, streamline headlines to "API Changes", "Changes" and "Fixes", finer subdivisions only raise noise, duplicates and discussions and, if not used consequently, do not add much benefit.	2022-01-23 20:58:49 +01:00
link2xt	81de882e2f	Add Protected Headers standard to standards.md	2022-01-23 19:47:10 +00:00
link2xt	593e07cdff	cargo update	2022-01-23 19:31:34 +00:00
B. Petersen	8ca54f616e	raise webxdc sending limit to 640 kb as discussed in dev chat, 100 kb is too low if one wants to use any game framework. also, many game that doesn't have poor graphics or uses magic CSS-tricks to do fancy draws, will have more than 100 kb probably just in tiles and sprites. even for regions with low resources, 100 kb is low for a game - esp. if we compare that with stickers that are send around as well are not deduplicated and also have several 100 kb in size - for much less effect. we should still encourage ppl to create tiny apps, however, a too low limit also restricts possibilities wrt adaption.	2022-01-23 12:48:25 +01:00
link2xt	f7f899f0a4	smtp: retry immediately if connection is stale	2022-01-22 21:17:01 +00:00
B. Petersen	05a3c0c89b	webxdc: synchronous state for read-only-chats already before, we did _not_ sent updates to contact requests or other read-only-chats. however, we _did_ modify the local database, so that getAllUpdates() returns an update that was not sent out to other peers. this is fixed by checking can_send() soon. that way, all peers have the same state also for contact requests or other read-only-chats and webxdc in contact requests can be opened as usual. further ui improvements may be needed for contact requests (maybe allow the webxdc to know about that state or maybe show a warning in the ui somewhere), however, this is not part of this pr.	2022-01-22 21:28:47 +01:00
link2xt	f21691c122	Add "database_encrypted" field to Context.get_info()	2022-01-22 14:43:37 +00:00
B. Petersen	836e26d8d0	refine mergeable summary	2022-01-22 15:27:25 +01:00
B. Petersen	8a7c1fe4cb	mergeable: adding #skip-changelog to pr description skips the corresponding test	2022-01-22 14:35:12 +01:00
bjoern	7f43d3bb37	let sending invalid webxdc fail (#2993 ) * let sending invalid webxdc fail invalid webxdc can still be send as Viewtype::File, however (maybe one want to discuss errors or so ;) * clarify the supported zip compression methods	2022-01-22 11:19:21 +01:00
bjoern	11b975ab19	use new webxdc logo (#2994 ) * use webxdc logo * optimize png	2022-01-22 11:01:05 +01:00
bjoern	315e4215d9	make update messages work if a key is missing (#2998 ) * add a test for unencrypted replies to encrypted webxdc instances * make update messages work if a key is missing even in opportunistic chats, replies to encrypted messages are forced to be encrypted, if that is not possbile, message sending fails. while this is okay to not leak previously send text messages, the quotes as used by webxdc are more artificial, currently only the static text "Webxdc". * changelog ...	2022-01-22 10:56:15 +01:00
dependabot[bot]	e35e6c44cf	cargo: bump stop-token from 0.6.1 to 0.7.0 Bumps [stop-token](https://github.com/async-rs/stop-token) from 0.6.1 to 0.7.0. - [Release notes](https://github.com/async-rs/stop-token/releases) - [Commits](https://github.com/async-rs/stop-token/commits) --- updated-dependencies: - dependency-name: stop-token dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com>	2022-01-20 21:11:49 +00:00
Floris Bruynooghe	260cb78e3a	Re-write the blob filename creation loop This was written in a way which attempted to avoid easily creating an infinite loop. But really that's a python idiom and doesn't work very well in Rust. Worse, as shown by #2972 it is really easy to still get this wrong. Instead do this the rust way, this way the compiler can also reason properly about the branches and what is unreachable removing some bogus dead code.	2022-01-20 21:55:32 +01:00
link2xt	a1f04d2129	imex: use `param2` for passphrase	2022-01-16 13:22:08 +00:00
bjoern	9b562eebcd	handle parent for webxdc info-messages (#2984 ) * set parent for webxdc info-messages * test parent() for info-messages * add dc_msg_get_parent() ffi	2022-01-19 11:46:32 +01:00
Simon Laux	1d175c4557	update changelog for 1.71 (#2968 ) * update changelog for 1.71 * Apply suggestions from code review Co-authored-by: bjoern <r10s@b44t.com> Co-authored-by: bjoern <r10s@b44t.com>	2022-01-17 18:39:24 +01:00
Simon Laux	f755070080	apply wording suggestion from @r10s	2022-01-17 18:37:53 +01:00
Simon Laux	1c6c72a0fe	try fixing the mergeable configuration	2022-01-17 18:37:53 +01:00
Simon Laux	1755f2ea3d	update readme in deltachat-ffi to try out the changelog check	2022-01-17 18:37:53 +01:00
Simon Laux	498cc6c80b	add mergable changelog test	2022-01-17 18:37:53 +01:00
bjoern	8d3227a92b	fix webxdc forwarding and drafts (#2979 ) * fix forwarding webxdc instances, add a test for that * adapt webxdc test to fail on info-messages added when in draft mode * do not add info-messages when in draft-mode * half the number of instance-loads per webxdc update send/receive	2022-01-17 14:23:35 +01:00
Hocuri	c6d855084e	Save "configured" flag later (#2974 ) While experimenting with encrypted storage, once configuring failed between 920 and 940. But as the "configured" config had already been written after progress 910, some part of the code thought we are configured, some didn't.	2022-01-16 20:37:28 +01:00
Hocuri	827b3f8aeb	Create parent directory if creating a new file fails (#2978 ) With this PR, my encrypted-storage Android PR now works, at least I couldn't find any further bugs. Without it, configuring fails with: `Failed to create blob icon-saved-messages-1803424689.png in /data/user/0/com.b44t.messenger.beta/files/accounts/0e402b37dcd14a9586aea46294c908f2/dc.db-blobs: No such file or directory (os error 2)`. Also see https://github.com/deltachat/deltachat-core-rust/pull/2972.	2022-01-16 20:37:02 +01:00
link2xt	fb95573000	cargo update	2022-01-16 09:56:20 +00:00
dependabot[bot]	f026bd455f	Merge pull request #2966 from deltachat/dependabot/cargo/tagger-4.2.1	2022-01-16 09:46:41 +00:00
dependabot[bot]	f0b92a5757	Merge pull request #2976 from deltachat/dependabot/cargo/smallvec-1.8.0	2022-01-16 09:45:28 +00:00
dependabot[bot]	d7c6f1e63b	cargo: bump smallvec from 1.7.0 to 1.8.0 Bumps [smallvec](https://github.com/servo/rust-smallvec) from 1.7.0 to 1.8.0. - [Release notes](https://github.com/servo/rust-smallvec/releases) - [Commits](https://github.com/servo/rust-smallvec/compare/v1.7.0...v1.8.0) --- updated-dependencies: - dependency-name: smallvec dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com>	2022-01-14 21:19:37 +00:00
Hocuri	1e9e308df3	Fix clippy errors (#2973 )	2022-01-14 17:34:19 +01:00
dependabot[bot]	8b4b241403	cargo: bump tagger from 4.0.1 to 4.2.1 Bumps [tagger](https://github.com/tiby312/tagger) from 4.0.1 to 4.2.1. - [Release notes](https://github.com/tiby312/tagger/releases) - [Commits](https://github.com/tiby312/tagger/commits) --- updated-dependencies: - dependency-name: tagger dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com>	2022-01-13 10:13:45 +00:00
link2xt	afd8c0d879	Add `smtp` table It replaces SendMsgToSmtp job. Prepared outgoing SMTP payloads are stored in the database now rather than files in blobdir.	2022-01-01 19:14:53 +00:00
B. Petersen	6316ee7c9b	add editable "summary" to `dc_msg_get_webxdc_info()` the summary can be modified by the apps using `sendUpdate({summary: "foo", payload: ...})` the summary is updated when there is no newer update and chat will be informed by the change as usual by `DC_EVENT_MSGS_CHANGED`.	2022-01-16 00:30:53 +01:00
B. Petersen	b6b8d11881	add option to trigger an info-message from an webxdc-update	2022-01-16 00:30:53 +01:00
Hocuri	8753fd5887	Actually return a sensible error from create_new_file()	2022-01-15 18:33:17 +01:00
bjoern	5aaafb5ac1	limit webxdc-sizes for a better ux (#2971 ) * limit webxdc-sizes for a better ux * Update src/webxdc.rs Co-authored-by: Asiel Díaz Benítez <adbenitez@nauta.cu> * Update src/webxdc.rs Co-authored-by: Asiel Díaz Benítez <adbenitez@nauta.cu> Co-authored-by: Asiel Díaz Benítez <adbenitez@nauta.cu>	2022-01-15 00:12:00 +01:00
B. Petersen	a043557c44	move payload to {payload:PAYLOAD} to allow additional parameters additional parameters will be `summary` and `msg` (for an info-message) right now, and maybe more in the future (`aggregated`, `fast`, `to` ...), so adding just more parameters easily gets wild. also, this makes adaptions easier as no ffi needs to be adapted when we add more parameters. finally, sending is in-sync with receiving, database and wire now, one receives similar objects as one sends, which also looks like the right thing :) for now, `sendUpdate()` also allows to use the old, unwrapped payload to not immediately break existing `.xdc`, however, that will be removed soon, probably before the first release.	2022-01-15 00:10:59 +01:00
B. Petersen	4af4914e32	simplify WebxdcStatusUpdate handling	2022-01-15 00:10:59 +01:00