add chat.get_summary

(returns a lot like the original function chatlit.getsummary but it doesn't need a chatlist to work)
Mark location-only messages as auto-generated
2026-09-22 04:58:47 +03:00 · 2020-07-15 22:51:21 +02:00 · 2020-07-15 02:16:20 +03:00 · 2020-07-14 23:46:36 +02:00 · 2020-07-14 23:26:48 +03:00 · 2020-07-14 23:26:48 +03:00
56 changed files with 2358 additions and 1160 deletions
--- a/ASYNC-API-TODO.txt
+++ b/ASYNC-API-TODO.txt
@@ -1,54 +0,0 @@
-
-Delta Chat ASYNC  (friedel, bjoern, floris, friedel)
-
- smtp fake-idle/load jobs gerade noch alle fuenf sekunden , sollte alle zehn minuten (oder gar nicht)
-
-APIs:
-    dc_context_new                 # opens the database
-    dc_open                             # FFI only
-      -> drop it and move parameters to dc_context_new()
-
-    dc_configure                      # note: dc_start_jobs() is NOT allowed to run concurrently
-    dc_imex NEVER goes through the job system
-    dc_imex import_backup needs to ensure dc_stop_jobs()
-
-    dc_start_io                # start smtp/imap and job handling subsystems
-    dc_stop_io                 # stop smtp/imap and job handling subsystems
-    dc_is_io_running           # return 1 if smtp/imap/jobs susbystem is running
-
-    dc_close                            # FFI only
-      -> can be dropped
-    dc_context_unref
-
-    for ios share-extension:
-    Int dc_direct_send()  -> try send out without going through jobs system, but queue a job in db if it needs to be retried on failure
-        0: message was sent
-        1: message failed to go out, is queued as a job to be retried later
-        2: message permanently failed?
-
-EVENT handling:
-    start a callback thread and call get_next_event() which is BLOCKING
-    it's fine to start this callback thread later, it will see all events.
-    Note that the core infinitely fills the internal queue if you never drain it.
-
-    FFI-get_next_event() returns NULL if the context is unrefed already?
-
-   sidenote: how python's callback thread does it currently:
-         CB-thread runs this while loop:
-         while not QUITFLAG:
-             ev = context.get_next_event( )
-             ...
-         So in order to shutdown properly one has to set QUITFLAG
-         before calling dc_stop_jobs() and dc_context_unref
-
-    event API:
-        get_data1_int
-        get_data2_int
-        get_data3_str
-
-
- userdata likely only used for the callbacks, likely can be dropped, needs verification
-
-
- iOS needs for the share app to call "try_send_smtp" wihtout a full dc_context_run and without going
-
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,30 @@
 # Changelog 

+## 1.40.0
+
+- introduce ephemeral messages #1540 #1680 #1683 #1684 #1691 #1692
+
+- `DC_MSG_ID_DAYMARKER` gets timestamp attached #1677 #1685
+
+- improve idle #1690 #1688
+
+- fix message processing issues by sequential processing #1694
+
+- refactorings #1670 #1673
+
+
+## 1.39.0
+
+- fix handling of `mvbox_watch`, `sentbox_watch`, `inbox_watch` #1654 #1658
+
+- fix potential panics, update dependencies #1650 #1655
+
+
+## 1.38.0
+
+- fix sorting, esp. for multi-device
+
+
 ## 1.37.0

 - improve ndn heuristics #1630
@@ -16,6 +41,8 @@
 - parse ndn (network delivery notification) reports
  and report failed messages as such #1552 #1622 #1630

+- add oauth2 support for gsuite domains #1626
+
 - read image orientation from exif before recoding #1619

 - improve logging #1593 #1598
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,9 +2,9 @@
 # It is not intended for manual editing.
 [[package]]
 name = "addr2line"
-version = "0.12.1"
+version = "0.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a49806b9dadc843c61e7c97e72490ad7f7220ae249012fbda9ad0609457c0543"
+checksum = "602d785912f476e480434627e8732e6766b760c045bbf897d9dfaa9f4fbd399c"
 dependencies = [
 "gimli",
 ]
@@ -238,9 +238,9 @@ dependencies = [

 [[package]]
 name = "async-std"
-version = "1.6.1"
+version = "1.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b93c583a035d21e6d6f09adf48abfc55277bf48886406df370e5db6babe3ab98"
+checksum = "00d68a33ebc8b57800847d00787307f84a562224a14db069b0acefe4c2abbf5d"
 dependencies = [
 "async-attributes",
 "async-task",
@@ -281,9 +281,9 @@ checksum = "c17772156ef2829aadc587461c7753af20b7e8db1529bc66855add962a3b35d3"

 [[package]]
 name = "async-trait"
-version = "0.1.35"
+version = "0.1.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89cb5d814ab2a47fd66d3266e9efccb53ca4c740b7451043b8ffcf9a6208f3f8"
+checksum = "a265e3abeffdce30b2e26b7a11b222fe37c6067404001b434101457d0385eb92"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -459,6 +459,19 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c98bfd7c112b6399fef97cc0614af1cd375b27a112e552ce60f94c1b5f13cb74"

+[[package]]
+name = "blocking"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d17efb70ce4421e351d61aafd90c16a20fb5bfe339fcdc32a86816280e62ce0"
+dependencies = [
+ "futures-channel",
+ "futures-util",
+ "once_cell",
+ "parking",
+ "waker-fn",
+]
+
 [[package]]
 name = "blowfish"
 version = "0.5.0"
@@ -536,6 +549,12 @@ dependencies = [
 "iovec",
 ]

+[[package]]
+name = "cache-padded"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24508e28c677875c380c20f4d28124fab6f8ed4ef929a1397d7b1a31e92f1005"
+
 [[package]]
 name = "cargo_metadata"
 version = "0.6.4"
@@ -633,6 +652,15 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0dbbb57365263e881e805dc77d94697c9118fd94d8da011240555aa7b23445bd"

+[[package]]
+name = "concurrent-queue"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83c06aff61f2d899eb87c379df3cbf7876f14471dcab474e0b6dc90ab96c080"
+dependencies = [
+ "cache-padded",
+]
+
 [[package]]
 name = "constant_time_eq"
 version = "0.1.5"
@@ -686,32 +714,6 @@ dependencies = [
 "cfg-if",
 ]

-[[package]]
-name = "crossbeam-deque"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f02af974daeee82218205558e51ec8768b48cf524bd01d550abe5573a608285"
-dependencies = [
- "crossbeam-epoch",
- "crossbeam-utils",
- "maybe-uninit",
-]
-
-[[package]]
-name = "crossbeam-epoch"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "058ed274caafc1f60c4997b5fc07bf7dc7cca454af7c6e81edffe5f33f70dace"
-dependencies = [
- "autocfg 1.0.0",
- "cfg-if",
- "crossbeam-utils",
- "lazy_static",
- "maybe-uninit",
- "memoffset",
- "scopeguard",
-]
-
 [[package]]
 name = "crossbeam-queue"
 version = "0.2.3"
@@ -802,6 +804,12 @@ dependencies = [
 "syn",
 ]

+[[package]]
+name = "data-encoding"
+version = "2.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72aa14c04dfae8dd7d8a2b1cb7ca2152618cd01336dbfe704b8dcbf8d41dbd69"
+
 [[package]]
 name = "deflate"
 version = "0.8.4"
@@ -814,7 +822,7 @@ dependencies = [

 [[package]]
 name = "deltachat"
-version = "1.37.0"
+version = "1.40.0"
 dependencies = [
 "ansi_term 0.12.1",
 "anyhow",
@@ -886,7 +894,7 @@ dependencies = [

 [[package]]
 name = "deltachat_ffi"
-version = "1.37.0"
+version = "1.40.0"
 dependencies = [
 "anyhow",
 "async-std",
@@ -977,9 +985,9 @@ checksum = "212d0f5754cb6769937f4501cc0e67f4f4483c8d2c3e1e922ee9edbe4ab4c7c0"

 [[package]]
 name = "dtoa"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4358a9e11b9a09cf52383b451b49a169e8d797b68aa02301ff586d70d9661ea3"
+checksum = "134951f4028bdadb9b84baf4232681efbf277da25144b9b0ad65df75946c422b"

 [[package]]
 name = "ed25519-dalek"
@@ -1178,6 +1186,12 @@ dependencies = [
 "ascii_utils",
 ]

+[[package]]
+name = "fastrand"
+version = "1.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a64b0126b293b050395b37b10489951590ed024c03d7df4f249d219c8ded7cbf"
+
 [[package]]
 name = "flate2"
 version = "1.0.14"
@@ -1489,9 +1503,9 @@ dependencies = [

 [[package]]
 name = "http-types"
-version = "2.2.0"
+version = "2.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a89eaaf43f3700e78c01cb8165d1bd05155065637d26ee2f49800c95e7b62ee"
+checksum = "ca4221cd1c7cedf275cd0ad3c9dfe58b5acc93cdd5511c7e020a102e1995fe99"
 dependencies = [
 "anyhow",
 "async-std",
@@ -1501,6 +1515,7 @@ dependencies = [
 "rand 0.7.3",
 "serde",
 "serde_json",
+ "serde_qs",
 "serde_urlencoded",
 "url",
 ]
@@ -1554,9 +1569,9 @@ dependencies = [

 [[package]]
 name = "image"
-version = "0.23.5"
+version = "0.23.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d534e95ad8b9d5aa614322d02352b4f1bf962254adcf02ac6f2def8be18498e8"
+checksum = "b5b0553fec6407d63fe2975b794dfb099f3f790bdc958823851af37b26404ab4"
 dependencies = [
 "bytemuck",
 "byteorder",
@@ -1599,12 +1614,9 @@ dependencies = [

 [[package]]
 name = "infer"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d55c406a76164eb346a829ed4b97b73cb06259078eca01adeb12e8ca308d4123"
-dependencies = [
- "byteorder",
-]
+checksum = "6854dd77ddc4f9ba1a448f487e27843583d407648150426a30c2ea3a2c39490a"

 [[package]]
 name = "iovec"
@@ -1638,9 +1650,9 @@ dependencies = [

 [[package]]
 name = "itoa"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8b7a7c0c47db5545ed3fef7468ee7bb5b74691498139e4b3f6a20685dc6dd8e"
+checksum = "dc6f3ad7b9d11a0c00842ff8de1b60ee58661048eb8049ed33c73594f359d7e6"

 [[package]]
 name = "jpeg-decoder"
@@ -1838,15 +1850,6 @@ version = "2.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400"

-[[package]]
-name = "memoffset"
-version = "0.5.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4fc2c02a7e374099d4ee95a193111f72d2110197fe200272371758f6c3643d8"
-dependencies = [
- "autocfg 1.0.0",
-]
-
 [[package]]
 name = "mime"
 version = "0.3.16"
@@ -1994,9 +1997,9 @@ dependencies = [

 [[package]]
 name = "num-rational"
-version = "0.2.4"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c000134b5dbf44adc5cb772486d335293351644b801551abe8f75c84cfa4aef"
+checksum = "a5b4d7360f362cfb50dde8143501e6940b22f644be75a4cc90b2d81968908138"
 dependencies = [
 "autocfg 1.0.0",
 "num-integer",
@@ -2110,6 +2113,12 @@ dependencies = [
 "cfg-if",
 ]

+[[package]]
+name = "parking"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a7fad362df89617628a7508b3e9d588ade1b0ac31aa25de168193ad999c2dd4"
+
 [[package]]
 name = "parking_lot"
 version = "0.10.2"
@@ -2231,18 +2240,6 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"

-[[package]]
-name = "piper"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01608bfa680dafb103f9207fa944facf572e4e3e708d10de19a0d0c3d36e5f18"
-dependencies = [
- "crossbeam-utils",
- "futures-io",
- "futures-sink",
- "futures-util",
-]
-
 [[package]]
 name = "pkg-config"
 version = "0.3.17"
@@ -2719,10 +2716,10 @@ dependencies = [
 ]

 [[package]]
-name = "scoped-tls-hkt"
-version = "0.1.2"
+name = "scoped-tls"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2e9d7eaddb227e8fbaaa71136ae0e1e913ca159b86c7da82f3e8f0044ad3a63"
+checksum = "ea6a9290e3c9cf0f18145ef7ffa62d68ee0bf5fcd651017e586dc7fd5da448c2"

 [[package]]
 name = "scopeguard"
@@ -2777,18 +2774,18 @@ checksum = "f638d531eccd6e23b980caf34876660d38e265409d8e99b397ab71eb3612fad0"

 [[package]]
 name = "serde"
-version = "1.0.112"
+version = "1.0.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "736aac72d1eafe8e5962d1d1c3d99b0df526015ba40915cb3c49d042e92ec243"
+checksum = "5317f7588f0a5078ee60ef675ef96735a1442132dc645eb1d12c018620ed8cd3"
 dependencies = [
 "serde_derive",
 ]

 [[package]]
 name = "serde_derive"
-version = "1.0.112"
+version = "1.0.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf0343ce212ac0d3d6afd9391ac8e9c9efe06b533c8d33f660f6390cc4093f57"
+checksum = "2a0be94b04690fbaed37cddffc5c134bf537c8e3329d53e982fe04c374978f8e"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2806,6 +2803,18 @@ dependencies = [
 "serde",
 ]

+[[package]]
+name = "serde_qs"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6e32b85107a5c8062643265a90575cc6e798cec0906ea58519b42175062ba27"
+dependencies = [
+ "data-encoding",
+ "error-chain",
+ "percent-encoding",
+ "serde",
+]
+
 [[package]]
 name = "serde_urlencoded"
 version = "0.6.1"
@@ -2914,23 +2923,23 @@ checksum = "c7cb5678e1615754284ec264d9bb5b4c27d2018577fd90ac0ceb578591ed5ee4"

 [[package]]
 name = "smol"
-version = "0.1.12"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afcf8beb4aa23cc616e3351e49585153b462637c8fec929163b54d88e522b3b0"
+checksum = "620cbb3c6e34da57d3a248cda0cd01cd5848164dc062e764e65d06fe3ea7aed5"
 dependencies = [
 "async-task",
- "crossbeam-deque",
- "crossbeam-queue",
- "crossbeam-utils",
+ "blocking",
+ "concurrent-queue",
+ "fastrand",
 "futures-io",
 "futures-util",
 "libc",
 "once_cell",
- "piper",
- "scoped-tls-hkt",
+ "scoped-tls",
 "slab",
 "socket2",
- "wepoll-binding",
+ "wepoll-sys-stjepang",
+ "winapi",
 ]

 [[package]]
@@ -3098,9 +3107,9 @@ dependencies = [

 [[package]]
 name = "syn"
-version = "1.0.31"
+version = "1.0.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5304cfdf27365b7585c25d4af91b35016ed21ef88f17ced89c7093b43dba8b6"
+checksum = "e8d5d96e8cbb005d6959f119f773bfaebb5684296108fb32600c00cde305b2cd"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -3229,6 +3238,12 @@ dependencies = [
 "syn",
 ]

+[[package]]
+name = "tinyvec"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53953d2d3a5ad81d9f844a32f14ebb121f50b650cd59d0ee2a07cf13c617efed"
+
 [[package]]
 name = "tokio-io"
 version = "0.1.13"
@@ -3333,11 +3348,11 @@ dependencies = [

 [[package]]
 name = "unicode-normalization"
-version = "0.1.12"
+version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5479532badd04e128284890390c1e876ef7a993d0570b3597ae43dfa1d59afa4"
+checksum = "6fb19cf769fa8c6a80a162df694621ebeb4dafb606470b2b2fce0be40a98a977"
 dependencies = [
- "smallvec",
+ "tinyvec",
 ]

 [[package]]
@@ -3427,6 +3442,12 @@ dependencies = [
 "libc",
 ]

+[[package]]
+name = "waker-fn"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9571542c2ce85ce642e6b58b3364da2fb53526360dfb7c211add4f5c23105ff7"
+
 [[package]]
 name = "walkdir"
 version = "2.3.1"
@@ -3521,20 +3542,10 @@ dependencies = [
 ]

 [[package]]
-name = "wepoll-binding"
-version = "2.0.2"
+name = "wepoll-sys-stjepang"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "374fff4ff9701ff8b6ad0d14bacd3156c44063632d8c136186ff5967d48999a7"
-dependencies = [
- "bitflags",
- "wepoll-sys",
-]
-
-[[package]]
-name = "wepoll-sys"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9082a777aed991f6769e2b654aa0cb29f1c3d615daf009829b07b66c7aff6a24"
+checksum = "035f8ab1fcf98d41f8fd5206a97c335604162e5eb0c25c4839062093150ddc79"
 dependencies = [
 "cc",
 ]
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "deltachat"
-version = "1.37.0"
+version = "1.40.0"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"
 license = "MPL-2.0"

 [profile.release]
-lto = true
+#lto = true

 [dependencies]
 deltachat_derive = { path = "./deltachat_derive" }
--- a/README.md
+++ b/README.md
@@ -123,6 +123,7 @@ Language bindings are available for:
 - [Node.js](https://www.npmjs.com/package/deltachat-node)
 - [Python](https://py.delta.chat)
 - [Go](https://github.com/hugot/go-deltachat/)
+- [Free Pascal](https://github.com/deltachat/deltachat-fp/)
 - **Java** and **Swift** (contained in the Android/iOS repos)

 The following "frontend" projects make use of the Rust-library
--- a/contrib/proxy.py
+++ b/contrib/proxy.py
--- a/deltachat-ffi/Cargo.toml
+++ b/deltachat-ffi/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat_ffi"
-version = "1.37.0"
+version = "1.40.0"
 description = "Deltachat FFI"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"
--- a/deltachat-ffi/deltachat.h
+++ b/deltachat-ffi/deltachat.h
@@ -262,17 +262,25 @@ char*           dc_get_blobdir               (const dc_context_t* context);
 * - `selfavatar`   = File containing avatar. Will immediately be copied to the 
 *                    `blobdir`; the original image will not be needed anymore.
 *                    NULL to remove the avatar.
- *                    It is planned for future versions
- *                    to send this image together with the next messages.
+ *                    As for `displayname` and `selfstatus`, also the avatar is sent to the recipients.
+ *                    To save traffic, however, the avatar is attached only as needed
+ *                    and also recoded to a reasonable size.
 * - `e2ee_enabled` = 0=no end-to-end-encryption, 1=prefer end-to-end-encryption (default)
 * - `mdns_enabled` = 0=do not send or request read receipts,
 *                    1=send and request read receipts (default)
+ * - `bcc_self`     = 0=do not send a copy of outgoing messages to self (default),
+ *                    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.
 * - `inbox_watch`  = 1=watch `INBOX`-folder for changes (default),
- *                    0=do not watch the `INBOX`-folder
+ *                    0=do not watch the `INBOX`-folder,
+ *                    changes require restarting IO by calling dc_stop_io() and then dc_start_io().
 * - `sentbox_watch`= 1=watch `Sent`-folder for changes (default),
- *                    0=do not watch the `Sent`-folder
+ *                    0=do not watch the `Sent`-folder,
+ *                    changes require restarting IO by calling dc_stop_io() and then dc_start_io().
 * - `mvbox_watch`  = 1=watch `DeltaChat`-folder for changes (default),
- *                    0=do not watch the `DeltaChat`-folder
+ *                    0=do not watch the `DeltaChat`-folder,
+ *                    changes require restarting IO by calling dc_stop_io() and then dc_start_io().
 * - `mvbox_move`   = 1=heuristically detect chat-messages
 *                    and move them to the `DeltaChat`-folder,
 *                    0=do not move chat-messages
@@ -969,6 +977,7 @@ dc_msg_t*       dc_get_draft                 (dc_context_t* context, uint32_t ch
 * @param chat_id The chat ID of which the messages IDs should be queried.
 * @param flags If set to DC_GCM_ADDDAYMARKER, the marker DC_MSG_ID_DAYMARKER will
 *     be added before each day (regarding the local timezone).  Set this to 0 if you do not want this behaviour.
+ *     To get the concrete time of the marker, use dc_array_get_timestamp().
 * @param marker1before An optional message ID.  If set, the id DC_MSG_ID_MARKER1 will be added just
 *   before the given ID in the returned array.  Set this to 0 if you do not want this behaviour.
 * @return Array of message IDs, must be dc_array_unref()'d when no longer used.
@@ -1163,6 +1172,16 @@ void            dc_delete_chat               (dc_context_t* context, uint32_t ch
 */
 dc_array_t*     dc_get_chat_contacts         (dc_context_t* context, uint32_t chat_id);

+/**
+ * Get the chat's ephemeral message timer.
+ *
+ * @memberof dc_context_t
+ * @param context The context as created by dc_context_new().
+ * @param chat_id The chat ID.
+ *
+ * @return ephemeral timer value in seconds, 0 if the timer is disabled or if there is an error
+ */
+uint32_t dc_get_chat_ephemeral_timer (dc_context_t* context, uint32_t chat_id);

 /**
 * Search messages containing the given query string.
@@ -1295,6 +1314,21 @@ int             dc_remove_contact_from_chat  (dc_context_t* context, uint32_t ch
 */
 int             dc_set_chat_name             (dc_context_t* context, uint32_t chat_id, const char* name);

+/**
+ * Set the chat's ephemeral message timer.
+ *
+ * This timer is applied to all messages in a chat and starts when the
+ * message is read. The setting is synchronized to all clients
+ * participating in a chat.
+ *
+ * @memberof dc_context_t
+ * @param context The context as created by dc_context_new().
+ * @param chat_id The chat ID to set the ephemeral message timer for.
+ * @param timer The timer value in seconds or 0 to disable the timer.
+ *
+ * @return 1=success, 0=error
+ */
+int dc_set_chat_ephemeral_timer (dc_context_t* context, uint32_t chat_id, uint32_t timer);

 /**
 * Set group profile image.
@@ -2277,17 +2311,6 @@ int              dc_array_is_independent     (const dc_array_t* array, size_t in
 int              dc_array_search_id          (const dc_array_t* array, uint32_t needle, size_t* ret_index);


-/**
- * Get raw pointer to the data.
- *
- * @memberof dc_array_t
- * @param array The array object.
- * @return Raw pointer to the array. You MUST NOT free the data. You MUST NOT access the data beyond the current item count.
- *     It is not possible to enlarge the array this way.  Calling any other dc_array*()-function may discard the returned pointer.
- */
-const uint32_t*  dc_array_get_raw            (const dc_array_t* array);
-
-
 /**
 * @class dc_chatlist_t
 *
@@ -2416,6 +2439,32 @@ dc_lot_t*        dc_chatlist_get_summary     (const dc_chatlist_t* chatlist, siz
 dc_context_t*    dc_chatlist_get_context     (dc_chatlist_t* chatlist);


+/**
+ * Get a summary for a chat (same as dc_chatlist_get_summary only without the chatlist).
+ *
+ * The summary is returned by a dc_lot_t object with the following fields:
+ *
+ * - dc_lot_t::text1: contains the username or the strings "Me", "Draft" and so on.
+ *   The string may be colored by having a look at text1_meaning.
+ *   If there is no such name or it should not be displayed, the element is NULL.
+ *
+ * - dc_lot_t::text1_meaning: one of DC_TEXT1_USERNAME, DC_TEXT1_SELF or DC_TEXT1_DRAFT.
+ *   Typically used to show dc_lot_t::text1 with different colors. 0 if not applicable.
+ *
+ * - dc_lot_t::text2: contains an excerpt of the message text or strings as
+ *   "No messages".  May be NULL of there is no such text (eg. for the archive link)
+ *
+ * - dc_lot_t::timestamp: the timestamp of the message.  0 if not applicable.
+ *
+ * - dc_lot_t::state: The state of the message as one of the DC_STATE_* constants (see #dc_msg_get_state()).  0 if not applicable.
+ *
+ * @memberof dc_chat_t
+ * @param context
+ * @param chat The chat object.
+ * @return The summary as an dc_lot_t object. Must be freed using dc_lot_unref().  NULL is never returned.
+ */
+dc_lot_t*        dc_chat_get_summary     (dc_context_t* context, dc_chat_t* chat);
+
 /**
 * Get info summary for a chat, in json format.
 *
@@ -3003,6 +3052,32 @@ int             dc_msg_get_duration           (const dc_msg_t* msg);
 int             dc_msg_get_showpadlock        (const dc_msg_t* msg);


+/**
+ * Get ephemeral timer duration for message.
+ *
+ * To check if the timer is started and calculate remaining time,
+ * use dc_msg_get_ephemeral_timestamp().
+ *
+ * @memberof dc_msg_t
+ * @param msg The message object.
+ * @return Duration in seconds, or 0 if no timer is set.
+ */
+uint32_t        dc_msg_get_ephemeral_timer    (const dc_msg_t* msg);
+
+/**
+ * Get timestamp of ephemeral message removal.
+ *
+ * If returned value is non-zero, you can calculate the * fraction of
+ * time remaining by divinding the difference between the current timestamp
+ * and this timestamp by dc_msg_get_ephemeral_timer().
+ *
+ * @memberof dc_msg_t
+ * @param msg The message object.
+ * @return Time of message removal, 0 if the timer is not started.
+ */
+int64_t          dc_msg_get_ephemeral_timestamp (const dc_msg_t* msg);
+
+
 /**
 * Get a summary for a message.
 *
@@ -4171,6 +4246,11 @@ void dc_event_unref(dc_event_t* event);
 */
 #define DC_EVENT_CHAT_MODIFIED            2020

+/**
+ * Chat ephemeral timer changed.
+ */
+#define DC_EVENT_CHAT_EPHEMERAL_TIMER_MODIFIED 2021
+

 /**
 * Contact(s) created, renamed, verified, blocked or deleted.
@@ -4307,7 +4387,7 @@ void dc_event_unref(dc_event_t* event);
 */

 /**
- * Prover works out-of-the-box.
+ * Provider works out-of-the-box.
 * This provider status is returned for provider where the login
 * works by just entering the name or the email-address.
 *
@@ -4453,8 +4533,15 @@ void dc_event_unref(dc_event_t* event);
 #define DC_STR_UNKNOWN_SENDER_FOR_CHAT    72
 #define DC_STR_SUBJECT_FOR_NEW_CONTACT    73
 #define DC_STR_FAILED_SENDING_TO          74
+#define DC_STR_EPHEMERAL_DISABLED         75
+#define DC_STR_EPHEMERAL_SECONDS          76
+#define DC_STR_EPHEMERAL_MINUTE           77
+#define DC_STR_EPHEMERAL_HOUR             78
+#define DC_STR_EPHEMERAL_DAY              79
+#define DC_STR_EPHEMERAL_WEEK             80
+#define DC_STR_EPHEMERAL_FOUR_WEEKS       81

-#define DC_STR_COUNT                      74
+#define DC_STR_COUNT                      81

 /*
 * @}
--- a/deltachat-ffi/src/dc_array.rs
+++ b/deltachat-ffi/src/dc_array.rs
@@ -1,46 +1,56 @@
+use crate::chat::ChatItem;
+use crate::constants::{DC_MSG_ID_DAYMARKER, DC_MSG_ID_MARKER1};
 use crate::location::Location;
+use crate::message::MsgId;

 /* * the structure behind dc_array_t */
 #[derive(Debug, Clone)]
 pub enum dc_array_t {
+    MsgIds(Vec<MsgId>),
+    Chat(Vec<ChatItem>),
    Locations(Vec<Location>),
    Uint(Vec<u32>),
 }

 impl dc_array_t {
-    pub fn new(capacity: usize) -> Self {
-        dc_array_t::Uint(Vec::with_capacity(capacity))
-    }
-
-    /// Constructs a new, empty `dc_array_t` holding locations with specified `capacity`.
-    pub fn new_locations(capacity: usize) -> Self {
-        dc_array_t::Locations(Vec::with_capacity(capacity))
-    }
-
-    pub fn add_id(&mut self, item: u32) {
-        if let Self::Uint(array) = self {
-            array.push(item);
-        } else {
-            panic!("Attempt to add id to array of other type");
-        }
-    }
-
-    pub fn add_location(&mut self, location: Location) {
-        if let Self::Locations(array) = self {
-            array.push(location)
-        } else {
-            panic!("Attempt to add a location to array of other type");
-        }
-    }
-
-    pub fn get_id(&self, index: usize) -> u32 {
+    pub(crate) fn get_id(&self, index: usize) -> u32 {
        match self {
+            Self::MsgIds(array) => array[index].to_u32(),
+            Self::Chat(array) => match array[index] {
+                ChatItem::Message { msg_id } => msg_id.to_u32(),
+                ChatItem::Marker1 => DC_MSG_ID_MARKER1,
+                ChatItem::DayMarker { .. } => DC_MSG_ID_DAYMARKER,
+            },
            Self::Locations(array) => array[index].location_id,
-            Self::Uint(array) => array[index] as u32,
+            Self::Uint(array) => array[index],
        }
    }

-    pub fn get_location(&self, index: usize) -> &Location {
+    pub(crate) fn get_timestamp(&self, index: usize) -> Option<i64> {
+        match self {
+            Self::MsgIds(_) => None,
+            Self::Chat(array) => array.get(index).and_then(|item| match item {
+                ChatItem::Message { .. } => None,
+                ChatItem::Marker1 { .. } => None,
+                ChatItem::DayMarker { timestamp } => Some(*timestamp),
+            }),
+            Self::Locations(array) => array.get(index).map(|location| location.timestamp),
+            Self::Uint(_) => None,
+        }
+    }
+
+    pub(crate) fn get_marker(&self, index: usize) -> Option<&str> {
+        match self {
+            Self::MsgIds(_) => None,
+            Self::Chat(_) => None,
+            Self::Locations(array) => array
+                .get(index)
+                .and_then(|location| location.marker.as_deref()),
+            Self::Uint(_) => None,
+        }
+    }
+
+    pub(crate) fn get_location(&self, index: usize) -> &Location {
        if let Self::Locations(array) = self {
            &array[index]
        } else {
@@ -48,55 +58,18 @@ impl dc_array_t {
        }
    }

-    pub fn is_empty(&self) -> bool {
-        match self {
-            Self::Locations(array) => array.is_empty(),
-            Self::Uint(array) => array.is_empty(),
-        }
-    }
-
    /// Returns the number of elements in the array.
-    pub fn len(&self) -> usize {
+    pub(crate) fn len(&self) -> usize {
        match self {
+            Self::MsgIds(array) => array.len(),
+            Self::Chat(array) => array.len(),
            Self::Locations(array) => array.len(),
            Self::Uint(array) => array.len(),
        }
    }

-    pub fn clear(&mut self) {
-        match self {
-            Self::Locations(array) => array.clear(),
-            Self::Uint(array) => array.clear(),
-        }
-    }
-
-    pub fn search_id(&self, needle: u32) -> Option<usize> {
-        if let Self::Uint(array) = self {
-            for (i, &u) in array.iter().enumerate() {
-                if u == needle {
-                    return Some(i);
-                }
-            }
-            None
-        } else {
-            panic!("Attempt to search for id in array of other type");
-        }
-    }
-
-    pub fn sort_ids(&mut self) {
-        if let dc_array_t::Uint(v) = self {
-            v.sort();
-        } else {
-            panic!("Attempt to sort array of something other than uints");
-        }
-    }
-
-    pub fn as_ptr(&self) -> *const u32 {
-        if let dc_array_t::Uint(v) = self {
-            v.as_ptr()
-        } else {
-            panic!("Attempt to convert array of something other than uints to raw");
-        }
+    pub(crate) fn search_id(&self, needle: u32) -> Option<usize> {
+        (0..self.len()).find(|i| self.get_id(*i) == needle)
    }
 }

@@ -106,6 +79,18 @@ impl From<Vec<u32>> for dc_array_t {
    }
 }

+impl From<Vec<MsgId>> for dc_array_t {
+    fn from(array: Vec<MsgId>) -> Self {
+        dc_array_t::MsgIds(array)
+    }
+}
+
+impl From<Vec<ChatItem>> for dc_array_t {
+    fn from(array: Vec<ChatItem>) -> Self {
+        dc_array_t::Chat(array)
+    }
+}
+
 impl From<Vec<Location>> for dc_array_t {
    fn from(array: Vec<Location>) -> Self {
        dc_array_t::Locations(array)
@@ -118,12 +103,11 @@ mod tests {

    #[test]
    fn test_dc_array() {
-        let mut arr = dc_array_t::new(7);
-        assert!(arr.is_empty());
+        let arr: dc_array_t = Vec::<u32>::new().into();
+        assert!(arr.len() == 0);

-        for i in 0..1000 {
-            arr.add_id(i + 2);
-        }
+        let ids: Vec<u32> = (2..1002).collect();
+        let arr: dc_array_t = ids.into();

        assert_eq!(arr.len(), 1000);

@@ -131,31 +115,15 @@ mod tests {
            assert_eq!(arr.get_id(i), (i + 2) as u32);
        }

-        arr.clear();
-
-        assert!(arr.is_empty());
-
-        arr.add_id(13);
-        arr.add_id(7);
-        arr.add_id(666);
-        arr.add_id(0);
-        arr.add_id(5000);
-
-        arr.sort_ids();
-
-        assert_eq!(arr.get_id(0), 0);
-        assert_eq!(arr.get_id(1), 7);
-        assert_eq!(arr.get_id(2), 13);
-        assert_eq!(arr.get_id(3), 666);
+        assert_eq!(arr.search_id(10), Some(8));
+        assert_eq!(arr.search_id(1), None);
    }

    #[test]
    #[should_panic]
    fn test_dc_array_out_of_bounds() {
-        let mut arr = dc_array_t::new(7);
-        for i in 0..1000 {
-            arr.add_id(i + 2);
-        }
+        let ids: Vec<u32> = (2..1002).collect();
+        let arr: dc_array_t = ids.into();
        arr.get_id(1000);
    }
 }
--- a/deltachat-ffi/src/lib.rs
+++ b/deltachat-ffi/src/lib.rs
@@ -27,6 +27,7 @@ use deltachat::chat::{ChatId, ChatVisibility, MuteDuration};
 use deltachat::constants::DC_MSG_ID_LAST_SPECIAL;
 use deltachat::contact::{Contact, Origin};
 use deltachat::context::Context;
+use deltachat::ephemeral::Timer as EphemeralTimer;
 use deltachat::key::DcKey;
 use deltachat::message::MsgId;
 use deltachat::stock::StockMessage;
@@ -126,7 +127,7 @@ pub unsafe extern "C" fn dc_set_config(
        // When ctx.set_config() fails it already logged the error.
        // TODO: Context::set_config() should not log this
        Ok(key) => block_on(async move {
-            ctx.set_config(key, to_opt_string_lossy(value).as_ref().map(|x| x.as_str()))
+            ctx.set_config(key, to_opt_string_lossy(value).as_deref())
                .await
                .is_ok() as libc::c_int
        }),
@@ -349,7 +350,8 @@ pub unsafe extern "C" fn dc_event_get_data1_int(event: *mut dc_event_t) -> libc:
        | Event::MsgDelivered { chat_id, .. }
        | Event::MsgFailed { chat_id, .. }
        | Event::MsgRead { chat_id, .. }
-        | Event::ChatModified(chat_id) => chat_id.to_u32() as libc::c_int,
+        | Event::ChatModified(chat_id)
+        | Event::ChatEphemeralTimerModified { chat_id, .. } => chat_id.to_u32() as libc::c_int,
        Event::ContactsChanged(id) | Event::LocationChanged(id) => {
            let id = id.unwrap_or_default();
            id as libc::c_int
@@ -399,6 +401,7 @@ pub unsafe extern "C" fn dc_event_get_data2_int(event: *mut dc_event_t) -> libc:
        | Event::MsgRead { msg_id, .. } => msg_id.to_u32() as libc::c_int,
        Event::SecurejoinInviterProgress { progress, .. }
        | Event::SecurejoinJoinerProgress { progress, .. } => *progress as libc::c_int,
+        Event::ChatEphemeralTimerModified { timer, .. } => timer.to_u32() as libc::c_int,
    }
 }

@@ -439,7 +442,8 @@ pub unsafe extern "C" fn dc_event_get_data2_str(event: *mut dc_event_t) -> *mut
        | Event::ConfigureProgress(_)
        | Event::ImexProgress(_)
        | Event::SecurejoinInviterProgress { .. }
-        | Event::SecurejoinJoinerProgress { .. } => ptr::null_mut(),
+        | Event::SecurejoinJoinerProgress { .. }
+        | Event::ChatEphemeralTimerModified { .. } => ptr::null_mut(),
        Event::ImexFileWritten(file) => {
            let data2 = file.to_c_string().unwrap_or_default();
            data2.into_raw()
@@ -554,14 +558,7 @@ pub unsafe extern "C" fn dc_get_chatlist(
    let qi = if query_id == 0 { None } else { Some(query_id) };

    block_on(async move {
-        match chatlist::Chatlist::try_load(
-            &ctx,
-            flags as usize,
-            qs.as_ref().map(|x| x.as_str()),
-            qi,
-        )
-        .await
-        {
+        match chatlist::Chatlist::try_load(&ctx, flags as usize, qs.as_deref(), qi).await {
            Ok(list) => {
                let ffi_list = ChatlistWrapper { context, list };
                Box::into_raw(Box::new(ffi_list))
@@ -752,13 +749,9 @@ pub unsafe extern "C" fn dc_add_device_msg(
    };

    block_on(async move {
-        chat::add_device_msg(
-            &ctx,
-            to_opt_string_lossy(label).as_ref().map(|x| x.as_str()),
-            msg,
-        )
-        .await
-        .unwrap_or_log_default(&ctx, "Failed to add device message")
+        chat::add_device_msg(&ctx, to_opt_string_lossy(label).as_deref(), msg)
+            .await
+            .unwrap_or_log_default(&ctx, "Failed to add device message")
    })
    .to_u32()
 }
@@ -841,14 +834,11 @@ pub unsafe extern "C" fn dc_get_chat_msgs(
    };

    block_on(async move {
-        let arr = dc_array_t::from(
+        Box::into_raw(Box::new(
            chat::get_chat_msgs(&ctx, ChatId::new(chat_id), flags, marker_flag)
                .await
-                .iter()
-                .map(|msg_id| msg_id.to_u32())
-                .collect::<Vec<u32>>(),
-        );
-        Box::into_raw(Box::new(arr))
+                .into(),
+        ))
    })
 }

@@ -977,7 +967,7 @@ pub unsafe extern "C" fn dc_get_chat_media(
        from_prim(or_msg_type3).expect(&format!("incorrect or_msg_type3 = {}", or_msg_type3));

    block_on(async move {
-        let arr = dc_array_t::from(
+        Box::into_raw(Box::new(
            chat::get_chat_media(
                &ctx,
                ChatId::new(chat_id),
@@ -986,11 +976,8 @@ pub unsafe extern "C" fn dc_get_chat_media(
                or_msg_type3,
            )
            .await
-            .iter()
-            .map(|msg_id| msg_id.to_u32())
-            .collect::<Vec<u32>>(),
-        );
-        Box::into_raw(Box::new(arr))
+            .into(),
+        ))
    })
 }

@@ -1296,6 +1283,49 @@ pub unsafe extern "C" fn dc_set_chat_mute_duration(
    })
 }

+#[no_mangle]
+pub unsafe extern "C" fn dc_get_chat_ephemeral_timer(
+    context: *mut dc_context_t,
+    chat_id: u32,
+) -> u32 {
+    if context.is_null() {
+        eprintln!("ignoring careless call to dc_get_chat_ephemeral_timer()");
+        return 0;
+    }
+    let ctx = &*context;
+
+    // Timer value 0 is returned in the rare case of a database error,
+    // but it is not dangerous since it is only meant to be used as a
+    // default when changing the value. Such errors should not be
+    // ignored when ephemeral timer value is used to construct
+    // message headers.
+    block_on(async move { ChatId::new(chat_id).get_ephemeral_timer(ctx).await })
+        .log_err(ctx, "Failed to get ephemeral timer")
+        .unwrap_or_default()
+        .to_u32()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_set_chat_ephemeral_timer(
+    context: *mut dc_context_t,
+    chat_id: u32,
+    timer: u32,
+) -> libc::c_int {
+    if context.is_null() {
+        eprintln!("ignoring careless call to dc_set_chat_ephemeral_timer()");
+        return 0;
+    }
+    let ctx = &*context;
+
+    block_on(async move {
+        ChatId::new(chat_id)
+            .set_ephemeral_timer(ctx, EphemeralTimer::from_u32(timer))
+            .await
+            .log_err(ctx, "Failed to set ephemeral timer")
+            .is_ok() as libc::c_int
+    })
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_get_msg_info(
    context: *mut dc_context_t,
@@ -1991,7 +2021,7 @@ pub unsafe extern "C" fn dc_array_get_timestamp(
        return 0;
    }

-    (*array).get_location(index).timestamp
+    (*array).get_timestamp(index).unwrap_or_default()
 }
 #[no_mangle]
 pub unsafe extern "C" fn dc_array_get_chat_id(
@@ -2038,7 +2068,7 @@ pub unsafe extern "C" fn dc_array_get_marker(
        return std::ptr::null_mut(); // NULL explicitly defined as "no markers"
    }

-    if let Some(s) = &(*array).get_location(index).marker {
+    if let Some(s) = (*array).get_marker(index) {
        s.strdup()
    } else {
        std::ptr::null_mut()
@@ -2066,16 +2096,6 @@ pub unsafe extern "C" fn dc_array_search_id(
    }
 }

-#[no_mangle]
-pub unsafe extern "C" fn dc_array_get_raw(array: *const dc_array_t) -> *const u32 {
-    if array.is_null() {
-        eprintln!("ignoring careless call to dc_array_get_raw()");
-        return ptr::null_mut();
-    }
-
-    (*array).as_ptr()
-}
-
 // Return the independent-state of the location at the given index.
 // Independent locations do not belong to the track of the user.
 // Returns 1 if location belongs to the track of the user,
@@ -2299,6 +2319,23 @@ pub unsafe extern "C" fn dc_chat_get_visibility(chat: *mut dc_chat_t) -> libc::c
    }
 }

+#[no_mangle]
+pub unsafe extern "C" fn dc_chat_get_summary(
+    context: *mut dc_context_t,
+    chat: *mut dc_chat_t,
+) -> *mut dc_lot_t {
+    if chat.is_null() {
+        eprintln!("ignoring careless call to dc_chat_get_summary()");
+        return ptr::null_mut();
+    }
+    let ffi_chat = &*chat;
+    let ctx = &*context;
+    block_on(async move {
+        let lot = ffi_chat.chat.get_summary(&ctx).await;
+        Box::into_raw(Box::new(lot))
+    })
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_chat_is_unpromoted(chat: *mut dc_chat_t) -> libc::c_int {
    if chat.is_null() {
@@ -2655,6 +2692,26 @@ pub unsafe extern "C" fn dc_msg_get_showpadlock(msg: *mut dc_msg_t) -> libc::c_i
    ffi_msg.message.get_showpadlock() as libc::c_int
 }

+#[no_mangle]
+pub unsafe extern "C" fn dc_msg_get_ephemeral_timer(msg: *mut dc_msg_t) -> u32 {
+    if msg.is_null() {
+        eprintln!("ignoring careless call to dc_msg_get_ephemeral_timer()");
+        return 0;
+    }
+    let ffi_msg = &*msg;
+    ffi_msg.message.get_ephemeral_timer()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn dc_msg_get_ephemeral_timestamp(msg: *mut dc_msg_t) -> i64 {
+    if msg.is_null() {
+        eprintln!("ignoring careless call to dc_msg_get_ephemeral_timer()");
+        return 0;
+    }
+    let ffi_msg = &*msg;
+    ffi_msg.message.get_ephemeral_timestamp()
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_msg_get_summary(
    msg: *mut dc_msg_t,
@@ -2816,7 +2873,7 @@ pub unsafe extern "C" fn dc_msg_set_file(
    let ffi_msg = &mut *msg;
    ffi_msg.message.set_file(
        to_string_lossy(file),
-        to_opt_string_lossy(filemime).as_ref().map(|x| x.as_str()),
+        to_opt_string_lossy(filemime).as_deref(),
    )
 }

--- a/examples/repl/cmdline.rs
+++ b/examples/repl/cmdline.rs
@@ -2,7 +2,7 @@ use std::str::FromStr;

 use anyhow::{bail, ensure};
 use async_std::path::Path;
-use deltachat::chat::{self, Chat, ChatId, ChatVisibility};
+use deltachat::chat::{self, Chat, ChatId, ChatItem, ChatVisibility};
 use deltachat::chatlist::*;
 use deltachat::constants::*;
 use deltachat::contact::*;
@@ -215,7 +215,7 @@ async fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
 async fn log_msglist(context: &Context, msglist: &[MsgId]) -> Result<(), Error> {
    let mut lines_out = 0;
    for &msg_id in msglist {
-        if msg_id.is_daymarker() {
+        if msg_id == MsgId::new(DC_MSG_ID_DAYMARKER) {
            println!(
                "--------------------------------------------------------------------------------"
            );
@@ -488,6 +488,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
        }
        "listchats" | "listarchived" | "chats" => {
            let listflags = if arg0 == "listarchived" { 0x01 } else { 0 };
+            let time_start = std::time::SystemTime::now();
            let chatlist = Chatlist::try_load(
                &context,
                listflags,
@@ -495,6 +496,9 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                None,
            )
            .await?;
+            let time_needed = std::time::SystemTime::now()
+                .duration_since(time_start)
+                .unwrap_or_default();

            let cnt = chatlist.len();
            if cnt > 0 {
@@ -553,6 +557,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
                println!("Location streaming enabled.");
            }
            println!("{} chats", cnt);
+            println!("{:?} to create this list", time_needed);
        }
        "chat" => {
            if sel_chat.is_none() && arg1.is_empty() {
@@ -569,6 +574,15 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
            let sel_chat = sel_chat.as_ref().unwrap();

            let msglist = chat::get_chat_msgs(&context, sel_chat.get_id(), 0x1, None).await;
+            let msglist: Vec<MsgId> = msglist
+                .into_iter()
+                .map(|x| match x {
+                    ChatItem::Message { msg_id } => msg_id,
+                    ChatItem::Marker1 => MsgId::new(DC_MSG_ID_MARKER1),
+                    ChatItem::DayMarker { .. } => MsgId::new(DC_MSG_ID_DAYMARKER),
+                })
+                .collect();
+
            let members = chat::get_chat_contacts(&context, sel_chat.id).await;
            let subtitle = if sel_chat.is_device_talk() {
                "device-talk".to_string()
--- a/python/src/deltachat/chat.py
+++ b/python/src/deltachat/chat.py
@@ -5,7 +5,7 @@ import calendar
 import json
 from datetime import datetime
 import os
-from .cutil import as_dc_charpointer, from_dc_charpointer, iter_array
+from .cutil import as_dc_charpointer, from_dc_charpointer, iter_array, DCLot
 from .capi import lib, ffi
 from . import const
 from .message import Message
@@ -139,6 +139,22 @@ class Chat(object):
        """
        return bool(lib.dc_chat_get_remaining_mute_duration(self.id))

+    def get_ephemeral_timer(self):
+        """ get ephemeral timer.
+
+        :returns: ephemeral timer value in seconds
+        """
+        return lib.dc_get_chat_ephemeral_timer(self.account._dc_context, self.id)
+
+    def set_ephemeral_timer(self, timer):
+        """ set ephemeral timer.
+
+        :param: timer value in seconds
+
+        :returns: None
+        """
+        return lib.dc_set_chat_ephemeral_timer(self.account._dc_context, self.id, timer)
+
    def get_type(self):
        """ (deprecated) return type of this chat.

@@ -328,6 +344,11 @@ class Chat(object):
        s = from_dc_charpointer(dc_res)
        return json.loads(s)

+    def get_summary_lot(self):
+        """ return summary lot of chat (used for displaying last message in a chatlist)"""
+        lot = lib.dc_chat_get_summary(self.account._dc_context, self._dc_chat)
+        return DCLot(lot)
+
    # ------  group management API ------------------------------

    def add_contact(self, obj):
--- a/python/src/deltachat/message.py
+++ b/python/src/deltachat/message.py
@@ -154,6 +154,26 @@ class Message(object):
        if ts:
            return datetime.utcfromtimestamp(ts)

+    @props.with_doc
+    def ephemeral_timer(self):
+        """Ephemeral timer in seconds
+
+        :returns: timer in seconds or None if there is no timer
+        """
+        timer = lib.dc_msg_get_ephemeral_timer(self._dc_msg)
+        if timer:
+            return timer
+
+    @props.with_doc
+    def ephemeral_timestamp(self):
+        """UTC time when the message will be deleted.
+
+        :returns: naive datetime.datetime() object or None if the timer is not started.
+        """
+        ts = lib.dc_msg_get_ephemeral_timestamp(self._dc_msg)
+        if ts:
+            return datetime.utcfromtimestamp(ts)
+
    def get_mime_headers(self):
        """ return mime-header object for an incoming message.

--- a/python/src/deltachat/testplugin.py
+++ b/python/src/deltachat/testplugin.py
@@ -152,7 +152,7 @@ class SessionLiveConfigFromURL:
            assert index == len(self.configlist), index
            res = requests.post(self.url)
            if res.status_code != 200:
-                pytest.skip("creating newtmpuser failed {!r}".format(res))
+                pytest.skip("creating newtmpuser failed with code {}: '{}'".format(res.status_code, res.text))
            d = res.json()
            config = dict(addr=d["email"], mail_pw=d["password"])
            self.configlist.append(config)
@@ -349,6 +349,7 @@ def acfactory(pytestconfig, tmpdir, request, session_liveconfig, data):
                if hasattr(acc, "_configtracker"):
                    acc._configtracker.wait_finish()
                    del acc._configtracker
+                acc.set_config("bcc_self", "0")
                if acc.is_configured() and not acc.is_started():
                    acc.start_io()
                print("{}: {} account was successfully setup".format(
--- a/python/tests/test_account.py
+++ b/python/tests/test_account.py
@@ -517,7 +517,7 @@ def test_basic_imap_api(acfactory, tmpdir):

    imap2 = ac2.direct_imap

-    ac2.direct_imap.idle_start()
+    imap2.idle_start()
    chat12.send_text("hello")
    ac2._evtracker.wait_next_incoming_message()

@@ -723,9 +723,9 @@ class TestOnlineAccount:

    def test_move_works_on_self_sent(self, acfactory):
        ac1 = acfactory.get_online_configuring_account(mvbox=True, move=True)
-        ac1.set_config("bcc_self", "1")
        ac2 = acfactory.get_online_configuring_account()
        acfactory.wait_configure_and_start_io()
+        ac1.set_config("bcc_self", "1")

        chat = acfactory.get_accepted_chat(ac1, ac2)
        chat.send_text("message1")
@@ -1542,6 +1542,94 @@ class TestOnlineAccount:
        assert msg.is_encrypted(), "Message is not encrypted"
        assert msg.chat == ac2.create_chat(ac4)

+    def test_immediate_autodelete(self, acfactory, lp):
+        ac1 = acfactory.get_online_configuring_account()
+        ac2 = acfactory.get_online_configuring_account(mvbox=False, move=False, sentbox=False)
+
+        # "1" means delete immediately, while "0" means do not delete
+        ac2.set_config("delete_server_after", "1")
+
+        acfactory.wait_configure_and_start_io()
+
+        imap = ac2.direct_imap
+        imap.idle_start()
+
+        lp.sec("ac1: create chat with ac2")
+        chat1 = ac1.create_chat(ac2)
+        ac2.create_chat(ac1)
+
+        sent_msg = chat1.send_text("hello")
+        imap.idle_check(terminate=False)
+
+        msg = ac2._evtracker.wait_next_incoming_message()
+        assert msg.text == "hello"
+
+        imap.idle_check(terminate=True)
+        assert len(imap.get_all_messages()) == 0
+
+        # Mark deleted message as seen and check that read receipt arrives
+        msg.mark_seen()
+        ev = ac1._evtracker.get_matching("DC_EVENT_MSG_READ")
+        assert ev.data1 == chat1.id
+        assert ev.data2 == sent_msg.id
+
+    def test_ephemeral_timer(self, acfactory, lp):
+        ac1, ac2 = acfactory.get_two_online_accounts()
+
+        lp.sec("ac1: create chat with ac2")
+        chat1 = ac1.create_chat(ac2)
+        chat2 = ac2.create_chat(ac1)
+
+        lp.sec("ac1: set ephemeral timer to 60")
+        chat1.set_ephemeral_timer(60)
+
+        lp.sec("ac1: check that ephemeral timer is set for chat")
+        assert chat1.get_ephemeral_timer() == 60
+        chat1_summary = chat1.get_summary()
+        assert chat1_summary["ephemeral_timer"] == {'Enabled': {'duration': 60}}
+
+        lp.sec("ac2: receive system message about ephemeral timer modification")
+        ac2._evtracker.get_matching("DC_EVENT_CHAT_EPHEMERAL_TIMER_MODIFIED")
+        system_message1 = ac2._evtracker.wait_next_incoming_message()
+        assert chat2.get_ephemeral_timer() == 60
+        assert system_message1.is_system_message()
+
+        # Disabled until markers are implemented
+        # assert "Ephemeral timer: 60\n" in system_message1.get_message_info()
+
+        lp.sec("ac2: send message to ac1")
+        sent_message = chat2.send_text("message")
+        assert sent_message.ephemeral_timer == 60
+        assert "Ephemeral timer: 60\n" in sent_message.get_message_info()
+
+        # Timer is started immediately for sent messages
+        assert sent_message.ephemeral_timestamp is not None
+        assert "Expires: " in sent_message.get_message_info()
+
+        lp.sec("ac1: waiting for message from ac2")
+        text_message = ac1._evtracker.wait_next_incoming_message()
+        assert text_message.text == "message"
+        assert text_message.ephemeral_timer == 60
+        assert "Ephemeral timer: 60\n" in text_message.get_message_info()
+
+        # Timer should not start until message is displayed
+        assert text_message.ephemeral_timestamp is None
+        assert "Expires: " not in text_message.get_message_info()
+        text_message.mark_seen()
+        text_message = ac1.get_message_by_id(text_message.id)
+        assert text_message.ephemeral_timestamp is not None
+        assert "Expires: " in text_message.get_message_info()
+
+        lp.sec("ac2: set ephemeral timer to 0")
+        chat2.set_ephemeral_timer(0)
+
+        lp.sec("ac1: receive system message about ephemeral timer modification")
+        ac1._evtracker.get_matching("DC_EVENT_CHAT_EPHEMERAL_TIMER_MODIFIED")
+        system_message2 = ac1._evtracker.wait_next_incoming_message()
+        assert system_message2.ephemeral_timer is None
+        assert "Ephemeral timer: " not in system_message2.get_message_info()
+        assert chat1.get_ephemeral_timer() == 0
+

 class TestGroupStressTests:
    def test_group_many_members_add_leave_remove(self, acfactory, lp):
--- a/set_core_version.py
+++ b/set_core_version.py
@@ -5,19 +5,29 @@ import sys
 import re
 import pathlib
 import subprocess
+from argparse import ArgumentParser

 rex = re.compile(r'version = "(\S+)"')

-def read_toml_version(relpath):
+
+def regex_matches(relpath, regex=rex):
    p = pathlib.Path(relpath)
    assert p.exists()
    for line in open(str(p)):
-        m = rex.match(line)
+        m = regex.match(line)
        if m is not None:
-            return m.group(1)
+            return m
+
+
+def read_toml_version(relpath):
+    res = regex_matches(relpath, rex)
+    if res is not None:
+        return res.group(1)
    raise ValueError("no version found in {}".format(relpath))

-def replace_toml_version(relpath, newversion):
+
+def replace_toml_version_and_lto(relpath, newversion):
+    lto_rex = re.compile(r'#?\s*lto =.*')
    p = pathlib.Path(relpath)
    assert p.exists()
    tmp_path = str(p) + "_tmp"
@@ -25,18 +35,32 @@ def replace_toml_version(relpath, newversion):
        for line in open(str(p)):
            m = rex.match(line)
            if m is not None:
+                print("{}: set version={}".format(relpath, newversion))
                f.write('version = "{}"\n'.format(newversion))
            else:
+                m = lto_rex.match(line)
+                if m:
+                    print("{}: setting lto = true".format(relpath))
+                    line = "lto = true\n"
                f.write(line)
    os.rename(tmp_path, str(p))

-if __name__ == "__main__":

-    if len(sys.argv) < 2:
-        for x in ("Cargo.toml", "deltachat-ffi/Cargo.toml"):
+def main():
+    parser = ArgumentParser(prog="set_core_version")
+    parser.add_argument("newversion")
+
+    toml_list = ["Cargo.toml", "deltachat-ffi/Cargo.toml"]
+    try:
+        opts = parser.parse_args()
+    except SystemExit:
+        print()
+        for x in toml_list:
            print("{}: {}".format(x, read_toml_version(x)))
+        print()
        raise SystemExit("need argument: new version, example: 1.25.0")
-    newversion = sys.argv[1]
+
+    newversion = opts.newversion
    if newversion.count(".") < 2:
        raise SystemExit("need at least two dots in version")

@@ -52,10 +76,13 @@ if __name__ == "__main__":
    else:
        raise SystemExit("CHANGELOG.md contains no entry for version: {}".format(newversion))

-    replace_toml_version("Cargo.toml", newversion)
-    replace_toml_version("deltachat-ffi/Cargo.toml", newversion)
+    replace_toml_version_and_lto("Cargo.toml", newversion)
+    replace_toml_version_and_lto("deltachat-ffi/Cargo.toml", newversion)

+    print("running cargo check")
    subprocess.call(["cargo", "check"])
+
+    print("adding changes to git index")
    subprocess.call(["git", "add", "-u"])
    # subprocess.call(["cargo", "update", "-p", "deltachat"])

@@ -63,3 +90,8 @@ if __name__ == "__main__":
    print("")
    print("   git tag {}".format(newversion))
    print("")
+
+
+if __name__ == "__main__":
+    main()
+
--- a/src/blob.rs
+++ b/src/blob.rs
@@ -497,7 +497,7 @@ mod tests {

    #[async_std::test]
    async fn test_create() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let blob = BlobObject::create(&t.ctx, "foo", b"hello").await.unwrap();
        let fname = t.ctx.get_blobdir().join("foo");
        let data = fs::read(fname).await.unwrap();
@@ -508,7 +508,7 @@ mod tests {

    #[async_std::test]
    async fn test_lowercase_ext() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let blob = BlobObject::create(&t.ctx, "foo.TXT", b"hello")
            .await
            .unwrap();
@@ -517,7 +517,7 @@ mod tests {

    #[async_std::test]
    async fn test_as_file_name() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let blob = BlobObject::create(&t.ctx, "foo.txt", b"hello")
            .await
            .unwrap();
@@ -526,7 +526,7 @@ mod tests {

    #[async_std::test]
    async fn test_as_rel_path() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let blob = BlobObject::create(&t.ctx, "foo.txt", b"hello")
            .await
            .unwrap();
@@ -535,7 +535,7 @@ mod tests {

    #[async_std::test]
    async fn test_suffix() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let blob = BlobObject::create(&t.ctx, "foo.txt", b"hello")
            .await
            .unwrap();
@@ -546,7 +546,7 @@ mod tests {

    #[async_std::test]
    async fn test_create_dup() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        BlobObject::create(&t.ctx, "foo.txt", b"hello")
            .await
            .unwrap();
@@ -570,7 +570,7 @@ mod tests {

    #[async_std::test]
    async fn test_double_ext_preserved() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        BlobObject::create(&t.ctx, "foo.tar.gz", b"hello")
            .await
            .unwrap();
@@ -595,7 +595,7 @@ mod tests {

    #[async_std::test]
    async fn test_create_long_names() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let s = "1".repeat(150);
        let blob = BlobObject::create(&t.ctx, &s, b"data").await.unwrap();
        let blobname = blob.as_name().split('/').last().unwrap();
@@ -604,7 +604,7 @@ mod tests {

    #[async_std::test]
    async fn test_create_and_copy() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let src = t.dir.path().join("src");
        fs::write(&src, b"boo").await.unwrap();
        let blob = BlobObject::create_and_copy(&t.ctx, &src).await.unwrap();
@@ -620,7 +620,7 @@ mod tests {

    #[async_std::test]
    async fn test_create_from_path() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;

        let src_ext = t.dir.path().join("external");
        fs::write(&src_ext, b"boo").await.unwrap();
@@ -638,7 +638,7 @@ mod tests {
    }
    #[async_std::test]
    async fn test_create_from_name_long() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let src_ext = t.dir.path().join("autocrypt-setup-message-4137848473.html");
        fs::write(&src_ext, b"boo").await.unwrap();
        let blob = BlobObject::new_from_path(&t.ctx, &src_ext).await.unwrap();
@@ -660,8 +660,40 @@ mod tests {

    #[test]
    fn test_sanitise_name() {
-        let (_, ext) =
+        let (stem, ext) =
            BlobObject::sanitise_name("Я ЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯЯ.txt");
        assert_eq!(ext, ".txt");
+        assert!(!stem.is_empty());
+
+        // the extensions are kept together as between stem and extension a number may be added -
+        // and `foo.tar.gz` should become `foo-1234.tar.gz` and not `foo.tar-1234.gz`
+        let (stem, ext) = BlobObject::sanitise_name("wot.tar.gz");
+        assert_eq!(stem, "wot");
+        assert_eq!(ext, ".tar.gz");
+
+        let (stem, ext) = BlobObject::sanitise_name(".foo.bar");
+        assert_eq!(stem, "");
+        assert_eq!(ext, ".foo.bar");
+
+        let (stem, ext) = BlobObject::sanitise_name("foo?.bar");
+        assert!(stem.contains("foo"));
+        assert!(!stem.contains("?"));
+        assert_eq!(ext, ".bar");
+
+        let (stem, ext) = BlobObject::sanitise_name("no-extension");
+        assert_eq!(stem, "no-extension");
+        assert_eq!(ext, "");
+
+        let (stem, ext) = BlobObject::sanitise_name("path/ignored\\this: is* forbidden?.c");
+        assert_eq!(ext, ".c");
+        assert!(!stem.contains("path"));
+        assert!(!stem.contains("ignored"));
+        assert!(stem.contains("this"));
+        assert!(stem.contains("forbidden"));
+        assert!(!stem.contains("/"));
+        assert!(!stem.contains("\\"));
+        assert!(!stem.contains(":"));
+        assert!(!stem.contains("*"));
+        assert!(!stem.contains("?"));
    }
 }
--- a/src/chat.rs
+++ b/src/chat.rs
@@ -15,6 +15,7 @@ use crate::constants::*;
 use crate::contact::*;
 use crate::context::Context;
 use crate::dc_tools::*;
+use crate::ephemeral::{delete_expired_messages, schedule_ephemeral_task, Timer as EphemeralTimer};
 use crate::error::{bail, ensure, format_err, Error};
 use crate::events::Event;
 use crate::job::{self, Action};
@@ -22,7 +23,26 @@ use crate::message::{self, InvalidMsgId, Message, MessageState, MsgId};
 use crate::mimeparser::SystemMessage;
 use crate::param::*;
 use crate::sql;
-use crate::stock::StockMessage;
+use crate::{lot::Lot, stock::StockMessage};
+
+/// An chat item, such as a message or a marker.
+#[derive(Debug, Copy, Clone)]
+pub enum ChatItem {
+    Message {
+        msg_id: MsgId,
+    },
+
+    /// A marker without inherent meaning. It is inserted before user
+    /// supplied MsgId.
+    Marker1,
+
+    /// Day marker, separating messages that correspond to different
+    /// days according to local time.
+    DayMarker {
+        /// Marker timestamp, for day markers
+        timestamp: i64,
+    },
+}

 /// Chat ID, including reserved IDs.
 ///
@@ -710,9 +730,69 @@ impl Chat {
                .unwrap_or_else(std::path::PathBuf::new),
            draft,
            is_muted: self.is_muted(),
+            ephemeral_timer: self.id.get_ephemeral_timer(context).await?,
        })
    }

+    /// Version of get_summary that just needs the chat no chatlist required
+    pub async fn get_summary(&self, context: &Context) -> Lot {
+        // The summary is created by the chat, not by the last message.
+        // This is because we may want to display drafts here or stuff as
+        // "is typing".
+        // Also, sth. as "No messages" would not work if the summary comes from a message.
+        let mut ret = Lot::new();
+
+        let lastmsg_id = context
+            .sql
+            .query_row(
+                concat!(
+                    "SELECT id, chat_id",
+                    " FROM msgs",
+                    " WHERE chat_id = ?",
+                    " ORDER BY id DESC",
+                    " LIMIT 1"
+                ),
+                paramsv![self.id],
+                |row| {
+                    let msg_id: MsgId = row.get("id")?;
+                    Ok(msg_id)
+                },
+            )
+            .await
+            .unwrap_or_default();
+
+        let mut lastcontact = None;
+
+        let lastmsg = if let Ok(lastmsg) = Message::load_from_db(context, lastmsg_id).await {
+            if lastmsg.from_id != DC_CONTACT_ID_SELF
+                && (self.typ == Chattype::Group || self.typ == Chattype::VerifiedGroup)
+            {
+                lastcontact = Contact::load_from_db(context, lastmsg.from_id).await.ok();
+            }
+
+            Some(lastmsg)
+        } else {
+            None
+        };
+
+        if self.id.is_archived_link() {
+            ret.text2 = None;
+        } else if lastmsg.is_none() || lastmsg.as_ref().unwrap().from_id == DC_CONTACT_ID_UNDEFINED
+        {
+            ret.text2 = Some(
+                context
+                    .stock_str(StockMessage::NoMessages)
+                    .await
+                    .to_string(),
+            );
+        } else {
+            ret.fill(&mut lastmsg.unwrap(), self, lastcontact.as_ref(), context)
+                .await;
+        }
+
+        ret
+    }
+
    pub fn get_visibility(&self) -> ChatVisibility {
        self.visibility
    }
@@ -886,11 +966,10 @@ impl Chat {

                    // the whole list of messages referenced may be huge;
                    // only use the oldest and and the parent message
-                    let parent_references = if let Some(n) = parent_references.find(' ') {
-                        &parent_references[0..n]
-                    } else {
-                        &parent_references
-                    };
+                    let parent_references = parent_references
+                        .find(' ')
+                        .and_then(|n| parent_references.get(..n))
+                        .unwrap_or(&parent_references);

                    if !parent_references.is_empty() && !parent_rfc724_mid.is_empty() {
                        // angle brackets are added by the mimefactory later
@@ -938,10 +1017,20 @@ impl Chat {
                    .await?;
            }

+            let ephemeral_timer = if msg.param.get_cmd() == SystemMessage::EphemeralTimerChanged {
+                EphemeralTimer::Disabled
+            } else {
+                self.id.get_ephemeral_timer(context).await?
+            };
+            let ephemeral_timestamp = match ephemeral_timer {
+                EphemeralTimer::Disabled => 0,
+                EphemeralTimer::Enabled { duration } => timestamp + i64::from(duration),
+            };
+
            // add message to the database

            if context.sql.execute(
-                        "INSERT INTO msgs (rfc724_mid, chat_id, from_id, to_id, timestamp, type, state, txt, param, hidden, mime_in_reply_to, mime_references, location_id) VALUES (?,?,?,?,?, ?,?,?,?,?, ?,?,?);",
+                        "INSERT INTO msgs (rfc724_mid, chat_id, from_id, to_id, timestamp, type, state, txt, param, hidden, mime_in_reply_to, mime_references, location_id, ephemeral_timer, ephemeral_timestamp) VALUES (?,?,?,?,?, ?,?,?,?,?, ?,?,?,?,?);",
                        paramsv![
                            new_rfc724_mid,
                            self.id,
@@ -956,6 +1045,8 @@ impl Chat {
                            new_in_reply_to,
                            new_references,
                            location_id as i32,
+                            ephemeral_timer,
+                            ephemeral_timestamp
                        ]
                    ).await.is_ok() {
                        msg_id = context.sql.get_rowid(
@@ -974,6 +1065,7 @@ impl Chat {
        } else {
            error!(context, "Cannot send message, not configured.",);
        }
+        schedule_ephemeral_task(context).await;

        Ok(MsgId::new(msg_id))
    }
@@ -1001,13 +1093,13 @@ impl rusqlite::types::ToSql for ChatVisibility {

 impl rusqlite::types::FromSql for ChatVisibility {
    fn column_result(value: rusqlite::types::ValueRef) -> rusqlite::types::FromSqlResult<Self> {
-        i64::column_result(value).and_then(|val| {
+        i64::column_result(value).map(|val| {
            match val {
-                2 => Ok(ChatVisibility::Pinned),
-                1 => Ok(ChatVisibility::Archived),
-                0 => Ok(ChatVisibility::Normal),
+                2 => ChatVisibility::Pinned,
+                1 => ChatVisibility::Archived,
+                0 => ChatVisibility::Normal,
                // fallback to to Normal for unknown values, may happen eg. on imports created by a newer version.
-                _ => Ok(ChatVisibility::Normal),
+                _ => ChatVisibility::Normal,
            }
        })
    }
@@ -1070,6 +1162,9 @@ pub struct ChatInfo {
    ///
    /// The exact time its muted can be found out via the `chat.mute_duration` property
    pub is_muted: bool,
+
+    /// Ephemeral message timer.
+    pub ephemeral_timer: EphemeralTimer,
    // ToDo:
    // - [ ] deaddrop,
    // - [ ] summary,
@@ -1580,11 +1675,16 @@ pub async fn get_chat_msgs(
    chat_id: ChatId,
    flags: u32,
    marker1before: Option<MsgId>,
-) -> Vec<MsgId> {
-    match delete_device_expired_messages(context).await {
+) -> Vec<ChatItem> {
+    match delete_expired_messages(context).await {
        Err(err) => warn!(context, "Failed to delete expired messages: {}", err),
        Ok(messages_deleted) => {
            if messages_deleted {
+                // Trigger reload of chatlist.
+                //
+                // On desktop chatlist is always shown on the side,
+                // and it is important to update the last message shown
+                // there.
                context.emit_event(Event::MsgsChanged {
                    msg_id: MsgId::new(0),
                    chat_id: ChatId::new(0),
@@ -1603,18 +1703,20 @@ pub async fn get_chat_msgs(
            let (curr_id, ts) = row?;
            if let Some(marker_id) = marker1before {
                if curr_id == marker_id {
-                    ret.push(MsgId::new(DC_MSG_ID_MARKER1));
+                    ret.push(ChatItem::Marker1);
                }
            }
            if (flags & DC_GCM_ADDDAYMARKER) != 0 {
                let curr_local_timestamp = ts + cnv_to_local;
                let curr_day = curr_local_timestamp / 86400;
                if curr_day != last_day {
-                    ret.push(MsgId::new(DC_MSG_ID_DAYMARKER));
+                    ret.push(ChatItem::DayMarker {
+                        timestamp: curr_day,
+                    });
                    last_day = curr_day;
                }
            }
-            ret.push(curr_id);
+            ret.push(ChatItem::Message { msg_id: curr_id });
        }
        Ok(ret)
    };
@@ -1746,52 +1848,6 @@ pub async fn marknoticed_all_chats(context: &Context) -> Result<(), Error> {
    Ok(())
 }

-/// Deletes messages which are expired according to "delete_device_after" setting.
-///
-/// Returns true if any message is deleted, so event can be emitted. If nothing
-/// has been deleted, returns false.
-pub async fn delete_device_expired_messages(context: &Context) -> Result<bool, Error> {
-    if let Some(delete_device_after) = context.get_config_delete_device_after().await {
-        let threshold_timestamp = time() - delete_device_after;
-
-        let self_chat_id = lookup_by_contact_id(context, DC_CONTACT_ID_SELF)
-            .await
-            .unwrap_or_default()
-            .0;
-        let device_chat_id = lookup_by_contact_id(context, DC_CONTACT_ID_DEVICE)
-            .await
-            .unwrap_or_default()
-            .0;
-
-        // Delete expired messages
-        //
-        // Only update the rows that have to be updated, to avoid emitting
-        // unnecessary "chat modified" events.
-        let rows_modified = context
-            .sql
-            .execute(
-                "UPDATE msgs \
-             SET txt = 'DELETED', chat_id = ? \
-             WHERE timestamp < ? \
-             AND chat_id > ? \
-             AND chat_id != ? \
-             AND chat_id != ?",
-                paramsv![
-                    DC_CHAT_ID_TRASH,
-                    threshold_timestamp,
-                    DC_CHAT_ID_LAST_SPECIAL,
-                    self_chat_id,
-                    device_chat_id
-                ],
-            )
-            .await?;
-
-        Ok(rows_modified > 0)
-    } else {
-        Ok(false)
-    }
-}
-
 pub async fn get_chat_media(
    context: &Context,
    chat_id: ChatId,
@@ -2672,10 +2728,12 @@ pub(crate) async fn get_chat_id_by_grpid(
 /// Adds a message to device chat.
 ///
 /// Optional `label` can be provided to ensure that message is added only once.
-pub async fn add_device_msg(
+/// If `important` is true, a notification will be sent.
+pub async fn add_device_msg_with_importance(
    context: &Context,
    label: Option<&str>,
    msg: Option<&mut Message>,
+    important: bool,
 ) -> Result<MsgId, Error> {
    ensure!(
        label.is_some() || msg.is_some(),
@@ -2735,12 +2793,24 @@ pub async fn add_device_msg(
    }

    if !msg_id.is_unset() {
-        context.emit_event(Event::IncomingMsg { chat_id, msg_id });
+        if important {
+            context.emit_event(Event::IncomingMsg { chat_id, msg_id });
+        } else {
+            context.emit_event(Event::MsgsChanged { chat_id, msg_id });
+        }
    }

    Ok(msg_id)
 }

+pub async fn add_device_msg(
+    context: &Context,
+    label: Option<&str>,
+    msg: Option<&mut Message>,
+) -> Result<MsgId, Error> {
+    add_device_msg_with_importance(context, label, msg, false).await
+}
+
 pub async fn was_device_msg_ever_added(context: &Context, label: &str) -> Result<bool, Error> {
    ensure!(!label.is_empty(), "empty label");
    if let Ok(()) = context
@@ -2783,9 +2853,16 @@ pub(crate) async fn delete_and_reset_all_device_msgs(context: &Context) -> Resul
 /// For example, it can be a message showing that a member was added to a group.
 pub(crate) async fn add_info_msg(context: &Context, chat_id: ChatId, text: impl AsRef<str>) {
    let rfc724_mid = dc_create_outgoing_rfc724_mid(None, "@device");
+    let ephemeral_timer = match chat_id.get_ephemeral_timer(context).await {
+        Err(e) => {
+            warn!(context, "Could not get timer for info msg: {}", e);
+            return;
+        }
+        Ok(ephemeral_timer) => ephemeral_timer,
+    };

    if let Err(e) = context.sql.execute(
-        "INSERT INTO msgs (chat_id,from_id,to_id, timestamp,type,state, txt,rfc724_mid) VALUES (?,?,?, ?,?,?, ?,?);",
+        "INSERT INTO msgs (chat_id,from_id,to_id, timestamp,type,state, txt,rfc724_mid,ephemeral_timer) VALUES (?,?,?, ?,?,?, ?,?,?);",
        paramsv![
            chat_id,
            DC_CONTACT_ID_INFO,
@@ -2795,6 +2872,7 @@ pub(crate) async fn add_info_msg(context: &Context, chat_id: ChatId, text: impl
            MessageState::InNoticed,
            text.as_ref().to_string(),
            rfc724_mid,
+            ephemeral_timer
        ]
    ).await {
        warn!(context, "Could not add info msg: {}", e);
@@ -2821,7 +2899,7 @@ mod tests {

    #[async_std::test]
    async fn test_chat_info() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let bob = Contact::create(&t.ctx, "bob", "bob@example.com")
            .await
            .unwrap();
@@ -2844,7 +2922,8 @@ mod tests {
                "color": 15895624,
                "profile_image": "",
                "draft": "",
-                "is_muted": false
+                "is_muted": false,
+                "ephemeral_timer": "Disabled"
            }
        "#;

@@ -2855,7 +2934,7 @@ mod tests {

    #[async_std::test]
    async fn test_get_draft_no_draft() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let chat_id = create_by_contact_id(&t.ctx, DC_CONTACT_ID_SELF)
            .await
            .unwrap();
@@ -2865,7 +2944,7 @@ mod tests {

    #[async_std::test]
    async fn test_get_draft_special_chat_id() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let draft = ChatId::new(DC_CHAT_ID_LAST_SPECIAL)
            .get_draft(&t.ctx)
            .await
@@ -2877,14 +2956,14 @@ mod tests {
    async fn test_get_draft_no_chat() {
        // This is a weird case, maybe this should be an error but we
        // do not get this info from the database currently.
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let draft = ChatId::new(42).get_draft(&t.ctx).await.unwrap();
        assert!(draft.is_none());
    }

    #[async_std::test]
    async fn test_get_draft() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let chat_id = create_by_contact_id(&t.ctx, DC_CONTACT_ID_SELF)
            .await
            .unwrap();
@@ -2900,7 +2979,7 @@ mod tests {
    #[async_std::test]
    async fn test_add_contact_to_chat_ex_add_self() {
        // Adding self to a contact should succeed, even though it's pointless.
-        let t = test_context().await;
+        let t = TestContext::new().await;
        let chat_id = create_group_chat(&t.ctx, VerifiedStatus::Unverified, "foo")
            .await
            .unwrap();
@@ -2912,7 +2991,7 @@ mod tests {

    #[async_std::test]
    async fn test_self_talk() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let chat_id = create_by_contact_id(&t.ctx, DC_CONTACT_ID_SELF)
            .await
            .unwrap();
@@ -2933,7 +3012,7 @@ mod tests {

    #[async_std::test]
    async fn test_deaddrop_chat() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let chat = Chat::load_from_db(&t.ctx, ChatId::new(DC_CHAT_ID_DEADDROP))
            .await
            .unwrap();
@@ -2948,7 +3027,7 @@ mod tests {

    #[async_std::test]
    async fn test_add_device_msg_unlabelled() {
-        let t = test_context().await;
+        let t = TestContext::new().await;

        // add two device-messages
        let mut msg1 = Message::new(Viewtype::Text);
@@ -2983,7 +3062,7 @@ mod tests {

    #[async_std::test]
    async fn test_add_device_msg_labelled() {
-        let t = test_context().await;
+        let t = TestContext::new().await;

        // add two device-messages with the same label (second attempt is not added)
        let mut msg1 = Message::new(Viewtype::Text);
@@ -3037,7 +3116,7 @@ mod tests {

    #[async_std::test]
    async fn test_add_device_msg_label_only() {
-        let t = test_context().await;
+        let t = TestContext::new().await;
        let res = add_device_msg(&t.ctx, Some(""), None).await;
        assert!(res.is_err());
        let res = add_device_msg(&t.ctx, Some("some-label"), None).await;
@@ -3057,7 +3136,7 @@ mod tests {

    #[async_std::test]
    async fn test_was_device_msg_ever_added() {
-        let t = test_context().await;
+        let t = TestContext::new().await;
        add_device_msg(&t.ctx, Some("some-label"), None).await.ok();
        assert!(was_device_msg_ever_added(&t.ctx, "some-label")
            .await
@@ -3081,7 +3160,7 @@ mod tests {

    #[async_std::test]
    async fn test_delete_device_chat() {
-        let t = test_context().await;
+        let t = TestContext::new().await;

        let mut msg = Message::new(Viewtype::Text);
        msg.text = Some("message text".to_string());
@@ -3101,7 +3180,7 @@ mod tests {

    #[async_std::test]
    async fn test_device_chat_cannot_sent() {
-        let t = test_context().await;
+        let t = TestContext::new().await;
        t.ctx.update_device_chats().await.unwrap();
        let (device_chat_id, _) =
            create_or_lookup_by_contact_id(&t.ctx, DC_CONTACT_ID_DEVICE, Blocked::Not)
@@ -3121,7 +3200,7 @@ mod tests {

    #[async_std::test]
    async fn test_delete_and_reset_all_device_msgs() {
-        let t = test_context().await;
+        let t = TestContext::new().await;
        let mut msg = Message::new(Viewtype::Text);
        msg.text = Some("message text".to_string());
        let msg_id1 = add_device_msg(&t.ctx, Some("some-label"), Some(&mut msg))
@@ -3158,7 +3237,7 @@ mod tests {
    #[async_std::test]
    async fn test_archive() {
        // create two chats
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let mut msg = Message::new(Viewtype::Text);
        msg.text = Some("foo".to_string());
        let msg_id = add_device_msg(&t.ctx, None, Some(&mut msg)).await.unwrap();
@@ -3272,7 +3351,7 @@ mod tests {

    #[async_std::test]
    async fn test_pinned() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;

        // create 3 chats, wait 1 second in between to get a reliable order (we order by time)
        let mut msg = Message::new(Viewtype::Text);
@@ -3331,7 +3410,7 @@ mod tests {

    #[async_std::test]
    async fn test_set_chat_name() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let chat_id = create_group_chat(&t.ctx, VerifiedStatus::Unverified, "foo")
            .await
            .unwrap();
@@ -3355,7 +3434,7 @@ mod tests {

    #[async_std::test]
    async fn test_create_same_chat_twice() {
-        let context = dummy_context().await;
+        let context = TestContext::new().await;
        let contact1 = Contact::create(&context.ctx, "bob", "bob@mail.de")
            .await
            .unwrap();
@@ -3374,7 +3453,7 @@ mod tests {

    #[async_std::test]
    async fn test_shall_attach_selfavatar() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let chat_id = create_group_chat(&t.ctx, VerifiedStatus::Unverified, "foo")
            .await
            .unwrap();
@@ -3398,7 +3477,7 @@ mod tests {

    #[async_std::test]
    async fn test_set_mute_duration() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let chat_id = create_group_chat(&t.ctx, VerifiedStatus::Unverified, "foo")
            .await
            .unwrap();
@@ -3466,7 +3545,7 @@ mod tests {

    #[async_std::test]
    async fn test_parent_is_encrypted() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let chat_id = create_group_chat(&t.ctx, VerifiedStatus::Unverified, "foo")
            .await
            .unwrap();
@@ -3477,4 +3556,20 @@ mod tests {
        chat_id.set_draft(&t.ctx, Some(&mut msg)).await;
        assert!(!chat_id.parent_is_encrypted(&t.ctx).await.unwrap());
    }
+
+    #[async_std::test]
+    async fn test_get_summary_unwrap() {
+        let t = TestContext::new().await;
+        let chat_id1 = create_group_chat(&t.ctx, VerifiedStatus::Unverified, "a chat")
+            .await
+            .unwrap();
+
+        let mut msg = Message::new(Viewtype::Text);
+        msg.set_text(Some("foo:\nbar \r\n test".to_string()));
+        chat_id1.set_draft(&t.ctx, Some(&mut msg)).await;
+
+        let chat = Chat::load_from_db(&t.ctx, chat_id1).await.unwrap();
+        let summary = chat.get_summary(&t.ctx).await;
+        assert_eq!(summary.get_text2().unwrap(), "foo: bar test"); // the linebreak should be removed from summary
+    }
 }
--- a/src/chatlist.rs
+++ b/src/chatlist.rs
@@ -5,6 +5,7 @@ use crate::chat::*;
 use crate::constants::*;
 use crate::contact::*;
 use crate::context::*;
+use crate::ephemeral::delete_expired_messages;
 use crate::error::{bail, ensure, Result};
 use crate::lot::Lot;
 use crate::message::{Message, MessageState, MsgId};
@@ -76,7 +77,7 @@ impl Chatlist {
    ///   chats
    /// - the flag DC_GCL_FOR_FORWARDING sorts "Saved messages" to the top of the chatlist
    ///   and hides the device-chat,
-    //    typically used on forwarding, may be combined with DC_GCL_NO_SPECIALS
+    ///   typically used on forwarding, may be combined with DC_GCL_NO_SPECIALS
    /// - if the flag DC_GCL_NO_SPECIALS is set, deaddrop and archive link are not added
    ///   to the list (may be used eg. for selecting chats on forwarding, the flag is
    ///   not needed when DC_GCL_ARCHIVED_ONLY is already set)
@@ -99,7 +100,7 @@ impl Chatlist {

        // Note that we do not emit DC_EVENT_MSGS_MODIFIED here even if some
        // messages get deleted to avoid reloading the same chatlist.
-        if let Err(err) = delete_device_expired_messages(context).await {
+        if let Err(err) = delete_expired_messages(context).await {
            warn!(context, "Failed to hide expired messages: {}", err);
        }

@@ -428,7 +429,7 @@ mod tests {

    #[async_std::test]
    async fn test_try_load() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let chat_id1 = create_group_chat(&t.ctx, VerifiedStatus::Unverified, "a chat")
            .await
            .unwrap();
@@ -476,7 +477,7 @@ mod tests {

    #[async_std::test]
    async fn test_sort_self_talk_up_on_forward() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        t.ctx.update_device_chats().await.unwrap();
        create_group_chat(&t.ctx, VerifiedStatus::Unverified, "a chat")
            .await
@@ -501,7 +502,7 @@ mod tests {

    #[async_std::test]
    async fn test_search_special_chat_names() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        t.ctx.update_device_chats().await.unwrap();

        let chats = Chatlist::try_load(&t.ctx, 0, Some("t-1234-s"), None)
@@ -534,7 +535,7 @@ mod tests {

    #[async_std::test]
    async fn test_get_summary_unwrap() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let chat_id1 = create_group_chat(&t.ctx, VerifiedStatus::Unverified, "a chat")
            .await
            .unwrap();
--- a/src/config.rs
+++ b/src/config.rs
@@ -11,7 +11,7 @@ use crate::dc_tools::*;
 use crate::events::Event;
 use crate::message::MsgId;
 use crate::mimefactory::RECOMMENDED_FILE_SIZE;
-use crate::{scheduler::InterruptInfo, stock::StockMessage};
+use crate::stock::StockMessage;

 /// The available configuration keys.
 #[derive(
@@ -117,9 +117,18 @@ pub enum Config {

    #[strum(serialize = "sys.config_keys")]
    SysConfigKeys,
+
+    #[strum(props(default = "0"))]
+    /// Whether we send a warning if the password is wrong (set to false when we send a warning
+    /// because we do not want to send a second warning)
+    NotifyAboutWrongPw,
 }

 impl Context {
+    pub async fn config_exists(&self, key: Config) -> bool {
+        self.sql.get_raw_config(self, key).await.is_some()
+    }
+
    /// Get a configuration key. Returns `None` if no value is set, and no default value found.
    pub async fn get_config(&self, key: Config) -> Option<String> {
        let value = match key {
@@ -201,22 +210,6 @@ impl Context {
                    None => self.sql.set_raw_config(self, key, None).await,
                }
            }
-            Config::InboxWatch => {
-                let ret = self.sql.set_raw_config(self, key, value).await;
-                self.interrupt_inbox(InterruptInfo::new(false, None)).await;
-                ret
-            }
-            Config::SentboxWatch => {
-                let ret = self.sql.set_raw_config(self, key, value).await;
-                self.interrupt_sentbox(InterruptInfo::new(false, None))
-                    .await;
-                ret
-            }
-            Config::MvboxWatch => {
-                let ret = self.sql.set_raw_config(self, key, value).await;
-                self.interrupt_mvbox(InterruptInfo::new(false, None)).await;
-                ret
-            }
            Config::Selfstatus => {
                let def = self.stock_str(StockMessage::StatusLine).await;
                let val = if value.is_none() || value.unwrap() == def {
@@ -286,7 +279,7 @@ mod tests {

    #[async_std::test]
    async fn test_selfavatar_outside_blobdir() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let avatar_src = t.dir.path().join("avatar.jpg");
        let avatar_bytes = include_bytes!("../test-data/image/avatar1000x1000.jpg");
        File::create(&avatar_src)
@@ -315,7 +308,7 @@ mod tests {

    #[async_std::test]
    async fn test_selfavatar_in_blobdir() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let avatar_src = t.ctx.get_blobdir().join("avatar.png");
        let avatar_bytes = include_bytes!("../test-data/image/avatar900x900.png");
        File::create(&avatar_src)
@@ -341,7 +334,7 @@ mod tests {

    #[async_std::test]
    async fn test_selfavatar_copy_without_recode() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let avatar_src = t.dir.path().join("avatar.png");
        let avatar_bytes = include_bytes!("../test-data/image/avatar64x64.png");
        File::create(&avatar_src)
@@ -365,7 +358,7 @@ mod tests {

    #[async_std::test]
    async fn test_media_quality_config_option() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let media_quality = t.ctx.get_config_int(Config::MediaQuality).await;
        assert_eq!(media_quality, 0);
        let media_quality = constants::MediaQuality::from_i32(media_quality).unwrap_or_default();
--- a/src/configure/mod.rs
+++ b/src/configure/mod.rs
@@ -1,7 +1,5 @@
 //! Email accounts autoconfiguration process module

-#![forbid(clippy::indexing_slicing)]
-
 mod auto_mozilla;
 mod auto_outlook;
 mod read_url;
@@ -70,16 +68,21 @@ impl Context {
    async fn inner_configure(&self) -> Result<()> {
        info!(self, "Configure ...");

-        let was_configured_before = self.is_configured().await;
        let mut param = LoginParam::from_database(self, "").await;
        let success = configure(self, &mut param).await;
+        self.set_config(Config::NotifyAboutWrongPw, None).await?;

        if let Some(provider) = provider::get_provider_info(&param.addr) {
-            if !was_configured_before {
-                if let Some(config_defaults) = &provider.config_defaults {
-                    for def in config_defaults.iter() {
+            if let Some(config_defaults) = &provider.config_defaults {
+                for def in config_defaults.iter() {
+                    if !self.config_exists(def.key).await {
                        info!(self, "apply config_defaults {}={}", def.key, def.value);
                        self.set_config(def.key, Some(def.value)).await?;
+                    } else {
+                        info!(
+                            self,
+                            "skip already set config_defaults {}={}", def.key, def.value
+                        );
                    }
                }
            }
@@ -98,11 +101,12 @@ impl Context {

        match success {
            Ok(_) => {
+                self.set_config(Config::NotifyAboutWrongPw, Some("1"))
+                    .await?;
                progress!(self, 1000);
                Ok(())
            }
            Err(err) => {
-                error!(self, "Configure Failed: {}", err);
                progress!(self, 0);
                Err(err)
            }
@@ -455,7 +459,10 @@ async fn try_imap_connections(
        .await
        .is_ok()
    {
-        return Ok(()); // we directly return here if it was autoconfig or the connection succeeded
+        return Ok(());
+    }
+    if was_autoconfig {
+        bail!("autoconfig did not succeed");
    }

    progress!(context, 670);
@@ -489,7 +496,7 @@ async fn try_imap_connection(
        return Ok(());
    }
    if was_autoconfig {
-        return Ok(());
+        bail!("autoconfig did not succeed");
    }

    progress!(context, 650 + variation * 30);
@@ -549,7 +556,7 @@ async fn try_smtp_connections(
        return Ok(());
    }
    if was_autoconfig {
-        return Ok(());
+        bail!("No SMTP connection");
    }
    progress!(context, 850);

@@ -623,7 +630,7 @@ mod tests {

    #[async_std::test]
    async fn test_no_panic_on_bad_credentials() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        t.ctx
            .set_config(Config::Addr, Some("probably@unexistant.addr"))
            .await
@@ -637,7 +644,7 @@ mod tests {

    #[async_std::test]
    async fn test_get_offline_autoconfig() {
-        let context = dummy_context().await.ctx;
+        let context = TestContext::new().await.ctx;

        let mut params = LoginParam::new();
        params.addr = "someone123@example.org".to_string();
--- a/src/constants.rs
+++ b/src/constants.rs
@@ -323,54 +323,6 @@ const DC_EVENT_FILE_COPIED: usize = 2055; // deprecated;
 const DC_EVENT_IS_OFFLINE: usize = 2081; // deprecated;
 const DC_ERROR_SEE_STRING: usize = 0; // deprecated;
 const DC_ERROR_SELF_NOT_IN_GROUP: usize = 1; // deprecated;
-const DC_STR_SELFNOTINGRP: usize = 21; // deprecated;
-
-// TODO: Strings need some doumentation about used placeholders.
-// These constants are used to set stock translation strings
-
-const DC_STR_NOMESSAGES: usize = 1;
-const DC_STR_SELF: usize = 2;
-const DC_STR_DRAFT: usize = 3;
-const DC_STR_VOICEMESSAGE: usize = 7;
-const DC_STR_DEADDROP: usize = 8;
-const DC_STR_IMAGE: usize = 9;
-const DC_STR_VIDEO: usize = 10;
-const DC_STR_AUDIO: usize = 11;
-const DC_STR_FILE: usize = 12;
-const DC_STR_STATUSLINE: usize = 13;
-const DC_STR_NEWGROUPDRAFT: usize = 14;
-const DC_STR_MSGGRPNAME: usize = 15;
-const DC_STR_MSGGRPIMGCHANGED: usize = 16;
-const DC_STR_MSGADDMEMBER: usize = 17;
-const DC_STR_MSGDELMEMBER: usize = 18;
-const DC_STR_MSGGROUPLEFT: usize = 19;
-const DC_STR_GIF: usize = 23;
-const DC_STR_ENCRYPTEDMSG: usize = 24;
-const DC_STR_E2E_AVAILABLE: usize = 25;
-const DC_STR_ENCR_TRANSP: usize = 27;
-const DC_STR_ENCR_NONE: usize = 28;
-const DC_STR_CANTDECRYPT_MSG_BODY: usize = 29;
-const DC_STR_FINGERPRINTS: usize = 30;
-const DC_STR_READRCPT: usize = 31;
-const DC_STR_READRCPT_MAILBODY: usize = 32;
-const DC_STR_MSGGRPIMGDELETED: usize = 33;
-const DC_STR_E2E_PREFERRED: usize = 34;
-const DC_STR_CONTACT_VERIFIED: usize = 35;
-const DC_STR_CONTACT_NOT_VERIFIED: usize = 36;
-const DC_STR_CONTACT_SETUP_CHANGED: usize = 37;
-const DC_STR_ARCHIVEDCHATS: usize = 40;
-const DC_STR_STARREDMSGS: usize = 41;
-const DC_STR_AC_SETUP_MSG_SUBJECT: usize = 42;
-const DC_STR_AC_SETUP_MSG_BODY: usize = 43;
-const DC_STR_CANNOT_LOGIN: usize = 60;
-const DC_STR_SERVER_RESPONSE: usize = 61;
-const DC_STR_MSGACTIONBYUSER: usize = 62;
-const DC_STR_MSGACTIONBYME: usize = 63;
-const DC_STR_MSGLOCATIONENABLED: usize = 64;
-const DC_STR_MSGLOCATIONDISABLED: usize = 65;
-const DC_STR_LOCATION: usize = 66;
-const DC_STR_STICKER: usize = 67;
-const DC_STR_COUNT: usize = 67;

 pub const DC_JOB_DELETE_MSG_ON_IMAP: i32 = 110;

--- a/src/contact.rs
+++ b/src/contact.rs
@@ -1,7 +1,5 @@
 //! Contacts module

-#![forbid(clippy::indexing_slicing)]
-
 use async_std::path::PathBuf;
 use deltachat_derive::*;
 use itertools::Itertools;
@@ -1258,7 +1256,7 @@ mod tests {

    #[async_std::test]
    async fn test_get_contacts() {
-        let context = dummy_context().await;
+        let context = TestContext::new().await;
        let contacts = Contact::get_all(&context.ctx, 0, Some("some2"))
            .await
            .unwrap();
@@ -1282,10 +1280,10 @@ mod tests {

    #[async_std::test]
    async fn test_is_self_addr() -> Result<()> {
-        let t = test_context().await;
+        let t = TestContext::new().await;
        assert!(t.ctx.is_self_addr("me@me.org").await.is_err());

-        let addr = configure_alice_keypair(&t.ctx).await;
+        let addr = t.configure_alice().await;
        assert_eq!(t.ctx.is_self_addr("me@me.org").await?, false);
        assert_eq!(t.ctx.is_self_addr(&addr).await?, true);

@@ -1295,7 +1293,7 @@ mod tests {
    #[async_std::test]
    async fn test_add_or_lookup() {
        // add some contacts, this also tests add_address_book()
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let book = concat!(
            "  Name one  \n one@eins.org \n",
            "Name two\ntwo@deux.net\n",
@@ -1408,7 +1406,7 @@ mod tests {

    #[async_std::test]
    async fn test_remote_authnames() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;

        // incoming mail `From: bob1 <bob@example.org>` - this should init authname and name
        let (contact_id, sth_modified) = Contact::add_or_lookup(
@@ -1471,7 +1469,7 @@ mod tests {

    #[async_std::test]
    async fn test_remote_authnames_create_empty() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;

        // manually create "claire@example.org" without a given name
        let contact_id = Contact::create(&t.ctx, "", "claire@example.org")
@@ -1518,7 +1516,7 @@ mod tests {

    #[async_std::test]
    async fn test_remote_authnames_edit_empty() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;

        // manually create "dave@example.org"
        let contact_id = Contact::create(&t.ctx, "dave1", "dave@example.org")
@@ -1562,7 +1560,7 @@ mod tests {

    #[async_std::test]
    async fn test_name_in_address() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;

        let contact_id = Contact::create(&t.ctx, "", "<dave@example.org>")
            .await
--- a/src/context.rs
+++ b/src/context.rs
@@ -6,6 +6,7 @@ use std::ops::Deref;

 use async_std::path::{Path, PathBuf};
 use async_std::sync::{channel, Arc, Mutex, Receiver, RwLock, Sender};
+use async_std::task;

 use crate::chat::*;
 use crate::config::Config;
@@ -14,12 +15,10 @@ use crate::contact::*;
 use crate::dc_tools::duration_to_str;
 use crate::error::*;
 use crate::events::{Event, EventEmitter, Events};
-use crate::job::{self, Action};
 use crate::key::{DcKey, SignedPublicKey};
 use crate::login_param::LoginParam;
 use crate::lot::Lot;
-use crate::message::{self, Message, MessengerMessage, MsgId};
-use crate::param::Params;
+use crate::message::{self, MsgId};
 use crate::scheduler::Scheduler;
 use crate::sql::Sql;
 use std::time::SystemTime;
@@ -52,10 +51,13 @@ pub struct InnerContext {
    pub(crate) generating_key_mutex: Mutex<()>,
    /// Mutex to enforce only a single running oauth2 is running.
    pub(crate) oauth2_mutex: Mutex<()>,
+    /// Mutex to prevent a race condition when a "your pw is wrong" warning is sent, resulting in multiple messeges being sent.
+    pub(crate) wrong_pw_warning_mutex: Mutex<()>,
    pub(crate) translated_stockstrings: RwLock<HashMap<usize, String>>,
    pub(crate) events: Events,

    pub(crate) scheduler: RwLock<Scheduler>,
+    pub(crate) ephemeral_task: RwLock<Option<task::JoinHandle<()>>>,

    creation_time: SystemTime,
 }
@@ -118,9 +120,11 @@ impl Context {
            last_smeared_timestamp: RwLock::new(0),
            generating_key_mutex: Mutex::new(()),
            oauth2_mutex: Mutex::new(()),
+            wrong_pw_warning_mutex: Mutex::new(()),
            translated_stockstrings: RwLock::new(HashMap::new()),
            events: Events::default(),
            scheduler: RwLock::new(Scheduler::Stopped),
+            ephemeral_task: RwLock::new(None),
            creation_time: std::time::SystemTime::now(),
        };

@@ -454,34 +458,6 @@ impl Context {
        self.get_config(Config::ConfiguredMvboxFolder).await
            == Some(folder_name.as_ref().to_string())
    }
-
-    pub async fn do_heuristics_moves(&self, folder: &str, msg_id: MsgId) {
-        if !self.get_config_bool(Config::MvboxMove).await {
-            return;
-        }
-
-        if self.is_mvbox(folder).await {
-            return;
-        }
-        if let Ok(msg) = Message::load_from_db(self, msg_id).await {
-            if msg.is_setupmessage() {
-                // do not move setup messages;
-                // there may be a non-delta device that wants to handle it
-                return;
-            }
-
-            match msg.is_dc_message {
-                MessengerMessage::No => {}
-                MessengerMessage::Yes | MessengerMessage::Reply => {
-                    job::add(
-                        self,
-                        job::Job::new(Action::MoveMsg, msg.id.to_u32(), Params::new(), 0),
-                    )
-                    .await;
-                }
-            }
-        }
-    }
 }

 impl InnerContext {
@@ -540,7 +516,7 @@ mod tests {

    #[async_std::test]
    async fn test_get_fresh_msgs() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let fresh = t.ctx.get_fresh_msgs().await;
        assert!(fresh.is_empty())
    }
@@ -595,13 +571,13 @@ mod tests {

    #[async_std::test]
    async fn no_crashes_on_context_deref() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        std::mem::drop(t.ctx);
    }

    #[async_std::test]
    async fn test_get_info() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;

        let info = t.ctx.get_info().await;
        assert!(info.get("database_dir").is_some());
--- a/src/dc_receive_imf.rs
+++ b/src/dc_receive_imf.rs
@@ -10,6 +10,7 @@ use crate::constants::*;
 use crate::contact::*;
 use crate::context::Context;
 use crate::dc_tools::*;
+use crate::ephemeral::{stock_ephemeral_timer_changed, Timer as EphemeralTimer};
 use crate::error::{bail, ensure, format_err, Result};
 use crate::events::Event;
 use crate::headerdef::HeaderDef;
@@ -45,13 +46,14 @@ pub async fn dc_receive_imf(
 ) -> Result<()> {
    info!(
        context,
-        "Receiving message {}/{}...",
+        "Receiving message {}/{}, seen={}...",
        if !server_folder.as_ref().is_empty() {
            server_folder.as_ref()
        } else {
            "?"
        },
        server_uid,
+        seen
    );

    if std::env::var(crate::DCC_MIME_DEBUG).unwrap_or_default() == "2" {
@@ -222,24 +224,29 @@ pub async fn dc_receive_imf(
                )
                .await;
            }
-        } else {
+        } else if insert_msg_id
+            .needs_move(context, server_folder.as_ref())
+            .await
+            .unwrap_or_default()
+        {
            // Move message if we don't delete it immediately.
-            context
-                .do_heuristics_moves(server_folder.as_ref(), insert_msg_id)
-                .await;
-            if !mime_parser.mdn_reports.is_empty() && mime_parser.has_chat_version() {
-                // This is a Delta Chat MDN. Mark as read.
-                job::add(
-                    context,
-                    job::Job::new(
-                        Action::MarkseenMsgOnImap,
-                        insert_msg_id.to_u32(),
-                        Params::new(),
-                        0,
-                    ),
-                )
-                .await;
-            }
+            job::add(
+                context,
+                job::Job::new(Action::MoveMsg, insert_msg_id.to_u32(), Params::new(), 0),
+            )
+            .await;
+        } else if !mime_parser.mdn_reports.is_empty() && mime_parser.has_chat_version() {
+            // This is a Delta Chat MDN. Mark as read.
+            job::add(
+                context,
+                job::Job::new(
+                    Action::MarkseenMsgOnImap,
+                    insert_msg_id.to_u32(),
+                    Params::new(),
+                    0,
+                ),
+            )
+            .await;
        }
    }

@@ -618,10 +625,78 @@ async fn add_parts(
            *chat_id = ChatId::new(DC_CHAT_ID_TRASH);
        }
    }
+
+    // Extract ephemeral timer from the message.
+    let mut ephemeral_timer = if let Some(value) = mime_parser.get(HeaderDef::EphemeralTimer) {
+        match value.parse::<EphemeralTimer>() {
+            Ok(timer) => timer,
+            Err(err) => {
+                warn!(
+                    context,
+                    "can't parse ephemeral timer \"{}\": {}", value, err
+                );
+                EphemeralTimer::Disabled
+            }
+        }
+    } else {
+        EphemeralTimer::Disabled
+    };
+
+    let location_kml_is = mime_parser.location_kml.is_some();
+    let is_mdn = !mime_parser.mdn_reports.is_empty();
+
+    // Apply ephemeral timer changes to the chat.
+    //
+    // Only non-hidden timers are applied now. Timers from hidden
+    // messages such as read receipts can be useful to detect
+    // ephemeral timer support, but timer changes without visible
+    // received messages may be confusing to the user.
+    if !*hidden
+        && !location_kml_is
+        && !is_mdn
+        && (*chat_id).get_ephemeral_timer(context).await? != ephemeral_timer
+    {
+        match (*chat_id)
+            .inner_set_ephemeral_timer(context, ephemeral_timer)
+            .await
+        {
+            Ok(()) => {
+                if mime_parser.is_system_message == SystemMessage::EphemeralTimerChanged {
+                    set_better_msg(
+                        mime_parser,
+                        stock_ephemeral_timer_changed(context, ephemeral_timer, from_id).await,
+                    );
+
+                    // Do not delete the system message itself.
+                    //
+                    // This prevents confusion when timer is changed
+                    // to 1 week, and then changed to 1 hour: after 1
+                    // hour, only the message about the change to 1
+                    // week is left.
+                    ephemeral_timer = EphemeralTimer::Disabled;
+                } else {
+                    chat::add_info_msg(
+                        context,
+                        *chat_id,
+                        stock_ephemeral_timer_changed(context, ephemeral_timer, from_id).await,
+                    )
+                    .await;
+                }
+            }
+            Err(err) => {
+                warn!(
+                    context,
+                    "failed to modify timer for chat {}: {}", chat_id, err
+                );
+            }
+        }
+    }
+
    // correct message_timestamp, it should not be used before,
    // however, we cannot do this earlier as we need from_id to be set
+    let in_fresh = state == MessageState::InFresh;
    let rcvd_timestamp = time();
-    let sort_timestamp = calc_sort_timestamp(context, *sent_timestamp, *chat_id, !seen).await;
+    let sort_timestamp = calc_sort_timestamp(context, *sent_timestamp, *chat_id, in_fresh).await;
    *sent_timestamp = std::cmp::min(*sent_timestamp, rcvd_timestamp);

    // unarchive chat
@@ -648,7 +723,6 @@ async fn add_parts(

    let mut parts = std::mem::replace(&mut mime_parser.parts, Vec::new());
    let server_folder = server_folder.as_ref().to_string();
-    let location_kml_is = mime_parser.location_kml.is_some();
    let is_system_message = mime_parser.is_system_message;
    let mime_headers = if save_mime_headers {
        Some(String::from_utf8_lossy(imf_raw).to_string())
@@ -658,7 +732,6 @@ async fn add_parts(
    let sent_timestamp = *sent_timestamp;
    let is_hidden = *hidden;
    let chat_id = *chat_id;
-    let is_mdn = !mime_parser.mdn_reports.is_empty();

    // TODO: can this clone be avoided?
    let rfc724_mid = rfc724_mid.to_string();
@@ -675,8 +748,8 @@ async fn add_parts(
                    "INSERT INTO msgs \
         (rfc724_mid, server_folder, server_uid, chat_id, from_id, to_id, timestamp, \
         timestamp_sent, timestamp_rcvd, type, state, msgrmsg,  txt, txt_raw, param, \
-         bytes, hidden, mime_headers,  mime_in_reply_to, mime_references, error) \
-         VALUES (?,?,?,?,?,?, ?,?,?,?,?,?, ?,?,?,?,?,?, ?,?, ?);",
+         bytes, hidden, mime_headers,  mime_in_reply_to, mime_references, error, ephemeral_timer, ephemeral_timestamp) \
+         VALUES (?,?,?,?,?,?, ?,?,?,?,?,?, ?,?,?,?,?,?, ?,?, ?,?,?);",
                )?;

                let is_location_kml = location_kml_is
@@ -698,6 +771,15 @@ async fn add_parts(
                    part.param.set_int(Param::Cmd, is_system_message as i32);
                }

+                let ephemeral_timestamp = if in_fresh {
+                    0
+                } else {
+                    match ephemeral_timer {
+                        EphemeralTimer::Disabled => 0,
+                        EphemeralTimer::Enabled { duration } => rcvd_timestamp + i64::from(duration)
+                    }
+                };
+
                stmt.execute(paramsv![
                    rfc724_mid,
                    server_folder,
@@ -721,6 +803,8 @@ async fn add_parts(
                    mime_in_reply_to,
                    mime_references,
                    part.error,
+                    ephemeral_timer,
+                    ephemeral_timestamp
                ])?;

                drop(stmt);
@@ -1444,6 +1528,7 @@ async fn create_adhoc_grp_id(context: &Context, member_ids: &[u32]) -> String {
    hex_hash(&members)
 }

+#[allow(clippy::indexing_slicing)]
 fn hex_hash(s: impl AsRef<str>) -> String {
    let bytes = s.as_ref().as_bytes();
    let result = Sha256::digest(bytes);
@@ -1496,7 +1581,7 @@ async fn search_chat_ids_by_contact_ids(
                            matches = 0;
                            mismatches = 0;
                        }
-                        if matches < contact_ids.len() && contact_id == contact_ids[matches] {
+                        if contact_ids.get(matches) == Some(&contact_id) {
                            matches += 1;
                        } else {
                            mismatches += 1;
@@ -1624,10 +1709,11 @@ async fn check_verified_properties(

 fn set_better_msg(mime_parser: &mut MimeMessage, better_msg: impl AsRef<str>) {
    let msg = better_msg.as_ref();
-    if !msg.is_empty() && !mime_parser.parts.is_empty() {
-        let part = &mut mime_parser.parts[0];
-        if part.typ == Viewtype::Text {
-            part.msg = msg.to_string();
+    if !msg.is_empty() {
+        if let Some(part) = mime_parser.parts.get_mut(0) {
+            if part.typ == Viewtype::Text {
+                part.msg = msg.to_string();
+            }
        }
    }
 }
@@ -1786,7 +1872,7 @@ fn dc_create_incoming_rfc724_mid(
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::chat::ChatVisibility;
+    use crate::chat::{ChatItem, ChatVisibility};
    use crate::chatlist::Chatlist;
    use crate::message::Message;
    use crate::test_utils::*;
@@ -1801,7 +1887,7 @@ mod tests {

    #[async_std::test]
    async fn test_grpid_simple() {
-        let context = dummy_context().await;
+        let context = TestContext::new().await;
        let raw = b"From: hello\n\
                    Subject: outer-subject\n\
                    In-Reply-To: <lqkjwelq123@123123>\n\
@@ -1818,7 +1904,7 @@ mod tests {

    #[async_std::test]
    async fn test_grpid_from_multiple() {
-        let context = dummy_context().await;
+        let context = TestContext::new().await;
        let raw = b"From: hello\n\
                    Subject: outer-subject\n\
                    In-Reply-To: <Gr.HcxyMARjyJy.9-qweqwe@asd.net>\n\
@@ -1855,7 +1941,7 @@ mod tests {

    #[async_std::test]
    async fn test_is_known_rfc724_mid() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let mut msg = Message::new(Viewtype::Text);
        msg.text = Some("first message".to_string());
        let msg_id = chat::add_device_msg(&t.ctx, None, Some(&mut msg))
@@ -1871,7 +1957,7 @@ mod tests {

    #[async_std::test]
    async fn test_is_msgrmsg_rfc724_mid() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let mut msg = Message::new(Viewtype::Text);
        msg.text = Some("first message".to_string());
        let msg_id = chat::add_device_msg(&t.ctx, None, Some(&mut msg))
@@ -1885,34 +1971,34 @@ mod tests {
        assert!(!is_msgrmsg_rfc724_mid(&t.ctx, "nonexistant@message.id").await);
    }

-    static MSGRMSG: &[u8] = b"From: Bob <bob@example.org>\n\
-                    To: alice@example.org\n\
+    static MSGRMSG: &[u8] = b"From: Bob <bob@example.com>\n\
+                    To: alice@example.com\n\
                    Chat-Version: 1.0\n\
                    Subject: Chat: hello\n\
-                    Message-ID: <Mr.1111@example.org>\n\
+                    Message-ID: <Mr.1111@example.com>\n\
                    Date: Sun, 22 Mar 2020 22:37:55 +0000\n\
                    \n\
                    hello\n";

-    static ONETOONE_NOREPLY_MAIL: &[u8] = b"From: Bob <bob@example.org>\n\
-                    To: alice@example.org\n\
+    static ONETOONE_NOREPLY_MAIL: &[u8] = b"From: Bob <bob@example.com>\n\
+                    To: alice@example.com\n\
                    Subject: Chat: hello\n\
-                    Message-ID: <2222@example.org>\n\
+                    Message-ID: <2222@example.com>\n\
                    Date: Sun, 22 Mar 2020 22:37:56 +0000\n\
                    \n\
                    hello\n";

-    static GRP_MAIL: &[u8] = b"From: bob@example.org\n\
-                    To: alice@example.org, claire@example.org\n\
+    static GRP_MAIL: &[u8] = b"From: bob@example.com\n\
+                    To: alice@example.com, claire@example.com\n\
                    Subject: group with Alice, Bob and Claire\n\
-                    Message-ID: <3333@example.org>\n\
+                    Message-ID: <3333@example.com>\n\
                    Date: Sun, 22 Mar 2020 22:37:57 +0000\n\
                    \n\
                    hello\n";

    #[async_std::test]
    async fn test_adhoc_group_show_chats_only() {
-        let t = configured_offline_context().await;
+        let t = TestContext::new_alice().await;
        assert_eq!(t.ctx.get_config_int(Config::ShowEmails).await, 0);

        let chats = Chatlist::try_load(&t.ctx, 0, None, None).await.unwrap();
@@ -1939,7 +2025,7 @@ mod tests {

    #[async_std::test]
    async fn test_adhoc_group_show_accepted_contact_unknown() {
-        let t = configured_offline_context().await;
+        let t = TestContext::new_alice().await;
        t.ctx
            .set_config(Config::ShowEmails, Some("1"))
            .await
@@ -1955,12 +2041,12 @@ mod tests {

    #[async_std::test]
    async fn test_adhoc_group_show_accepted_contact_known() {
-        let t = configured_offline_context().await;
+        let t = TestContext::new_alice().await;
        t.ctx
            .set_config(Config::ShowEmails, Some("1"))
            .await
            .unwrap();
-        Contact::create(&t.ctx, "Bob", "bob@example.org")
+        Contact::create(&t.ctx, "Bob", "bob@example.com")
            .await
            .unwrap();
        dc_receive_imf(&t.ctx, GRP_MAIL, "INBOX", 1, false)
@@ -1975,7 +2061,7 @@ mod tests {

    #[async_std::test]
    async fn test_adhoc_group_show_accepted_contact_accepted() {
-        let t = configured_offline_context().await;
+        let t = TestContext::new_alice().await;
        t.ctx
            .set_config(Config::ShowEmails, Some("1"))
            .await
@@ -2021,7 +2107,7 @@ mod tests {

    #[async_std::test]
    async fn test_adhoc_group_show_all() {
-        let t = configured_offline_context().await;
+        let t = TestContext::new_alice().await;
        t.ctx
            .set_config(Config::ShowEmails, Some("2"))
            .await
@@ -2046,7 +2132,7 @@ mod tests {
    #[async_std::test]
    async fn test_read_receipt_and_unarchive() {
        // create alice's account
-        let t = configured_offline_context().await;
+        let t = TestContext::new_alice().await;

        // create one-to-one with bob, archive one-to-one
        let bob_id = Contact::create(&t.ctx, "bob", "bob@exampel.org")
@@ -2089,14 +2175,14 @@ mod tests {
        dc_receive_imf(
            &t.ctx,
            format!(
-                "From: alice@example.org\n\
-                 To: bob@example.org\n\
+                "From: alice@example.com\n\
+                 To: bob@example.com\n\
                 Subject: foo\n\
-                 Message-ID: <Gr.{}.12345678901@example.org>\n\
+                 Message-ID: <Gr.{}.12345678901@example.com>\n\
                 Chat-Version: 1.0\n\
                 Chat-Group-ID: {}\n\
                 Chat-Group-Name: foo\n\
-                 Chat-Disposition-Notification-To: alice@example.org\n\
+                 Chat-Disposition-Notification-To: alice@example.com\n\
                 Date: Sun, 22 Mar 2020 22:37:57 +0000\n\
                 \n\
                 hello\n",
@@ -2111,7 +2197,11 @@ mod tests {
        .unwrap();
        let msgs = chat::get_chat_msgs(&t.ctx, group_id, 0, None).await;
        assert_eq!(msgs.len(), 1);
-        let msg_id = msgs.first().unwrap();
+        let msg_id = if let ChatItem::Message { msg_id } = msgs.first().unwrap() {
+            msg_id
+        } else {
+            panic!("Wrong item type");
+        };
        let msg = message::Message::load_from_db(&t.ctx, msg_id.clone())
            .await
            .unwrap();
@@ -2125,12 +2215,12 @@ mod tests {
        dc_receive_imf(
            &t.ctx,
            format!(
-                "From: bob@example.org\n\
-                 To: alice@example.org\n\
+                "From: bob@example.com\n\
+                 To: alice@example.com\n\
                 Subject: message opened\n\
                 Date: Sun, 22 Mar 2020 23:37:57 +0000\n\
                 Chat-Version: 1.0\n\
-                 Message-ID: <Mr.12345678902@example.org>\n\
+                 Message-ID: <Mr.12345678902@example.com>\n\
                 Content-Type: multipart/report; report-type=disposition-notification; boundary=\"SNIPP\"\n\
                 \n\
                 \n\
@@ -2144,9 +2234,9 @@ mod tests {
                 Content-Type: message/disposition-notification\n\
                 \n\
                 Reporting-UA: Delta Chat 1.28.0\n\
-                 Original-Recipient: rfc822;bob@example.org\n\
-                 Final-Recipient: rfc822;bob@example.org\n\
-                 Original-Message-ID: <Gr.{}.12345678901@example.org>\n\
+                 Original-Recipient: rfc822;bob@example.com\n\
+                 Final-Recipient: rfc822;bob@example.com\n\
+                 Original-Message-ID: <Gr.{}.12345678901@example.com>\n\
                 Disposition: manual-action/MDN-sent-automatically; displayed\n\
                 \n\
                 \n\
@@ -2186,7 +2276,7 @@ mod tests {
        // are very rare, however, we have to add them to the database (they go to the
        // "deaddrop" chat) to avoid a re-download from the server. See also [**]

-        let t = configured_offline_context().await;
+        let t = TestContext::new_alice().await;
        let context = &t.ctx;

        let chats = Chatlist::try_load(&t.ctx, 0, None, None).await.unwrap();
@@ -2194,9 +2284,9 @@ mod tests {

        dc_receive_imf(
            context,
-            b"To: bob@example.org\n\
+            b"To: bob@example.com\n\
                 Subject: foo\n\
-                 Message-ID: <3924@example.org>\n\
+                 Message-ID: <3924@example.com>\n\
                 Chat-Version: 1.0\n\
                 Date: Sun, 22 Mar 2020 22:37:57 +0000\n\
                 \n\
@@ -2215,7 +2305,7 @@ mod tests {

    #[async_std::test]
    async fn test_escaped_from() {
-        let t = configured_offline_context().await;
+        let t = TestContext::new_alice().await;
        let contact_id = Contact::create(&t.ctx, "foobar", "foobar@example.com")
            .await
            .unwrap();
@@ -2225,9 +2315,9 @@ mod tests {
        dc_receive_imf(
            &t.ctx,
            b"From: =?UTF-8?B?0JjQvNGPLCDQpNCw0LzQuNC70LjRjw==?= <foobar@example.com>\n\
-                 To: alice@example.org\n\
+                 To: alice@example.com\n\
                 Subject: foo\n\
-                 Message-ID: <asdklfjjaweofi@example.org>\n\
+                 Message-ID: <asdklfjjaweofi@example.com>\n\
                 Chat-Version: 1.0\n\
                 Chat-Disposition-Notification-To: =?UTF-8?B?0JjQvNGPLCDQpNCw0LzQuNC70LjRjw==?= <foobar@example.com>\n\
                 Date: Sun, 22 Mar 2020 22:37:57 +0000\n\
@@ -2246,7 +2336,11 @@ mod tests {
        );
        let msgs = chat::get_chat_msgs(&t.ctx, chat_id, 0, None).await;
        assert_eq!(msgs.len(), 1);
-        let msg_id = msgs.first().unwrap();
+        let msg_id = if let ChatItem::Message { msg_id } = msgs.first().unwrap() {
+            msg_id
+        } else {
+            panic!("Wrong item type");
+        };
        let msg = message::Message::load_from_db(&t.ctx, msg_id.clone())
            .await
            .unwrap();
@@ -2257,7 +2351,7 @@ mod tests {

    #[async_std::test]
    async fn test_escaped_recipients() {
-        let t = configured_offline_context().await;
+        let t = TestContext::new_alice().await;
        Contact::create(&t.ctx, "foobar", "foobar@example.com")
            .await
            .unwrap();
@@ -2271,10 +2365,10 @@ mod tests {
        dc_receive_imf(
            &t.ctx,
            b"From: Foobar <foobar@example.com>\n\
-                 To: =?UTF-8?B?0JjQvNGPLCDQpNCw0LzQuNC70LjRjw==?= alice@example.org\n\
+                 To: =?UTF-8?B?0JjQvNGPLCDQpNCw0LzQuNC70LjRjw==?= alice@example.com\n\
                 Cc: =?utf-8?q?=3Ch2=3E?= <carl@host.tld>\n\
                 Subject: foo\n\
-                 Message-ID: <asdklfjjaweofi@example.org>\n\
+                 Message-ID: <asdklfjjaweofi@example.com>\n\
                 Chat-Version: 1.0\n\
                 Chat-Disposition-Notification-To: <foobar@example.com>\n\
                 Date: Sun, 22 Mar 2020 22:37:57 +0000\n\
@@ -2305,7 +2399,7 @@ mod tests {

    #[async_std::test]
    async fn test_cc_to_contact() {
-        let t = configured_offline_context().await;
+        let t = TestContext::new_alice().await;
        Contact::create(&t.ctx, "foobar", "foobar@example.com")
            .await
            .unwrap();
@@ -2323,10 +2417,10 @@ mod tests {
        dc_receive_imf(
            &t.ctx,
            b"From: Foobar <foobar@example.com>\n\
-                 To: alice@example.org\n\
+                 To: alice@example.com\n\
                 Cc: Carl <carl@host.tld>\n\
                 Subject: foo\n\
-                 Message-ID: <asdklfjjaweofi@example.org>\n\
+                 Message-ID: <asdklfjjaweofi@example.com>\n\
                 Chat-Version: 1.0\n\
                 Chat-Disposition-Notification-To: <foobar@example.com>\n\
                 Date: Sun, 22 Mar 2020 22:37:57 +0000\n\
@@ -2427,7 +2521,8 @@ mod tests {
        raw_ndn: &[u8],
        error_msg: &str,
    ) {
-        let t = configured_offline_context_with_addr(self_addr).await;
+        let t = TestContext::new().await;
+        t.configure_addr(self_addr).await;

        dc_receive_imf(
            &t.ctx,
@@ -2472,18 +2567,19 @@ mod tests {

    #[async_std::test]
    async fn test_parse_ndn_group_msg() {
-        let t = configured_offline_context_with_addr("alice@gmail.com").await;
+        let t = TestContext::new().await;
+        t.configure_addr("alice@gmail.com").await;

        dc_receive_imf(
            &t.ctx,
            b"From: alice@gmail.com\n\
-                 To: bob@example.org, assidhfaaspocwaeofi@gmail.com\n\
+                 To: bob@example.com, assidhfaaspocwaeofi@gmail.com\n\
                 Subject: foo\n\
                 Message-ID: <CADWx9Cs32Wa7Gy-gM0bvbq54P_FEHe7UcsAV=yW7sVVW=fiMYQ@mail.gmail.com>\n\
                 Chat-Version: 1.0\n\
                 Chat-Group-ID: abcde\n\
                 Chat-Group-Name: foo\n\
-                 Chat-Disposition-Notification-To: alice@example.org\n\
+                 Chat-Disposition-Notification-To: alice@example.com\n\
                 Date: Sun, 22 Mar 2020 22:37:57 +0000\n\
                 \n\
                 hello\n",
@@ -2507,9 +2603,12 @@ mod tests {
        assert_eq!(msg.state, MessageState::OutFailed);

        let msgs = chat::get_chat_msgs(&t.ctx, msg.chat_id, 0, None).await;
-        let last_msg = Message::load_from_db(&t.ctx, *msgs.last().unwrap())
-            .await
-            .unwrap();
+        let msg_id = if let ChatItem::Message { msg_id } = msgs.last().unwrap() {
+            msg_id
+        } else {
+            panic!("Wrong item type");
+        };
+        let last_msg = Message::load_from_db(&t.ctx, *msg_id).await.unwrap();

        assert_eq!(
            last_msg.text,
--- a/src/dc_tools.rs
+++ b/src/dc_tools.rs
@@ -22,6 +22,7 @@ pub(crate) fn dc_exactly_one_bit_set(v: i32) -> bool {

 /// Shortens a string to a specified length and adds "[...]" to the
 /// end of the shortened string.
+#[allow(clippy::indexing_slicing)]
 pub(crate) fn dc_truncate(buf: &str, approx_chars: usize) -> Cow<str> {
    let ellipse = "[...]";

@@ -54,6 +55,7 @@ const COLORS: [u32; 16] = [
    0xf2_30_30, 0x39_b2_49, 0xbb_24_3b, 0x96_40_78, 0x66_87_4f, 0x30_8a_b9, 0x12_7e_d0, 0xbe_45_0c,
 ];

+#[allow(clippy::indexing_slicing)]
 pub(crate) fn dc_str_to_color(s: impl AsRef<str>) -> u32 {
    let str_lower = s.as_ref().to_lowercase();
    let mut checksum = 0;
@@ -198,7 +200,7 @@ fn encode_66bits_as_base64(v1: u32, v2: u32, fill: u32) -> String {
 pub(crate) fn dc_create_outgoing_rfc724_mid(grpid: Option<&str>, from_addr: &str) -> String {
    let hostname = from_addr
        .find('@')
-        .map(|k| &from_addr[k..])
+        .and_then(|k| from_addr.get(k..))
        .unwrap_or("@nohost");
    match grpid {
        Some(grpid) => format!("Gr.{}.{}{}", grpid, dc_create_id(), hostname),
@@ -774,7 +776,7 @@ mod tests {

    #[async_std::test]
    async fn test_file_handling() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let context = &t.ctx;
        macro_rules! dc_file_exist {
            ($ctx:expr, $fname:expr) => {
@@ -853,7 +855,7 @@ mod tests {

    #[async_std::test]
    async fn test_create_smeared_timestamp() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        assert_ne!(
            dc_create_smeared_timestamp(&t.ctx).await,
            dc_create_smeared_timestamp(&t.ctx).await
@@ -869,7 +871,7 @@ mod tests {

    #[async_std::test]
    async fn test_create_smeared_timestamps() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let count = MAX_SECONDS_TO_LEND_FROM_FUTURE - 1;
        let start = dc_create_smeared_timestamps(&t.ctx, count as usize).await;
        let next = dc_smeared_time(&t.ctx).await;
--- a/src/e2ee.rs
+++ b/src/e2ee.rs
@@ -115,6 +115,12 @@ impl EncryptHelper {
    }
 }

+/// Tries to decrypt a message, but only if it is structured as an
+/// Autocrypt message, i.e.  encrypted and signed with a valid
+/// signature.
+///
+/// Returns decrypted body and a set of valid signature fingerprints
+/// if successful.
 pub async fn try_decrypt(
    context: &Context,
    mail: &ParsedMail<'_>,
@@ -187,24 +193,23 @@ fn get_autocrypt_mime<'a, 'b>(mail: &'a ParsedMail<'b>) -> Result<&'a ParsedMail
        "Not a multipart/encrypted message: {}",
        mail.ctype.mimetype
    );
-    ensure!(
-        mail.subparts.len() == 2,
-        "Invalid Autocrypt Level 1 Mime Parts"
-    );
+    if let [first_part, second_part] = &mail.subparts[..] {
+        ensure!(
+            first_part.ctype.mimetype == "application/pgp-encrypted",
+            "Invalid Autocrypt Level 1 version part: {:?}",
+            first_part.ctype,
+        );

-    ensure!(
-        mail.subparts[0].ctype.mimetype == "application/pgp-encrypted",
-        "Invalid Autocrypt Level 1 version part: {:?}",
-        mail.subparts[0].ctype,
-    );
+        ensure!(
+            second_part.ctype.mimetype == "application/octet-stream",
+            "Invalid Autocrypt Level 1 encrypted part: {:?}",
+            second_part.ctype
+        );

-    ensure!(
-        mail.subparts[1].ctype.mimetype == "application/octet-stream",
-        "Invalid Autocrypt Level 1 encrypted part: {:?}",
-        mail.subparts[1].ctype
-    );
-
-    Ok(&mail.subparts[1])
+        Ok(second_part)
+    } else {
+        bail!("Invalid Autocrypt Level 1 Mime Parts")
+    }
 }

 async fn decrypt_if_autocrypt_message<'a>(
@@ -267,6 +272,7 @@ async fn decrypt_part(
    Ok(None)
 }

+#[allow(clippy::indexing_slicing)]
 fn has_decrypted_pgp_armor(input: &[u8]) -> bool {
    if let Some(index) = input.iter().position(|b| *b > b' ') {
        if input.len() - index > 26 {
@@ -327,14 +333,14 @@ mod tests {

        #[async_std::test]
        async fn test_prexisting() {
-            let t = dummy_context().await;
-            let test_addr = configure_alice_keypair(&t.ctx).await;
+            let t = TestContext::new().await;
+            let test_addr = t.configure_alice().await;
            assert_eq!(ensure_secret_key_exists(&t.ctx).await.unwrap(), test_addr);
        }

        #[async_std::test]
        async fn test_not_configured() {
-            let t = dummy_context().await;
+            let t = TestContext::new().await;
            assert!(ensure_secret_key_exists(&t.ctx).await.is_err());
        }
    }
--- a/src/ephemeral.rs
+++ b/src/ephemeral.rs
@@ -0,0 +1,528 @@
+//! # Ephemeral messages
+//!
+//! Ephemeral messages are messages that have an Ephemeral-Timer
+//! header attached to them, which specifies time in seconds after
+//! which the message should be deleted both from the device and from
+//! the server. The timer is started when the message is marked as
+//! seen, which usually happens when its contents is displayed on
+//! device screen.
+//!
+//! Each chat, including 1:1, group chats and "saved messages" chat,
+//! has its own ephemeral timer setting, which is applied to all
+//! messages sent to the chat. The setting is synchronized to all the
+//! devices participating in the chat by applying the timer value from
+//! all received messages, including BCC-self ones, to the chat. This
+//! way the setting is eventually synchronized among all participants.
+//!
+//! When user changes ephemeral timer setting for the chat, a system
+//! message is automatically sent to update the setting for all
+//! participants. This allows changing the setting for a chat like any
+//! group chat setting, e.g. name and avatar, without the need to
+//! write an actual message.
+//!
+//! ## Device settings
+//!
+//! In addition to per-chat ephemeral message setting, each device has
+//! two global user-configured settings that complement per-chat
+//! settings: `delete_device_after` and `delete_server_after`. These
+//! settings are not synchronized among devices and apply to all
+//! messages known to the device, including messages sent or received
+//! before configuring the setting.
+//!
+//! `delete_device_after` configures the maximum time device is
+//! storing the messages locally. `delete_server_after` configures the
+//! time after which device will delete the messages it knows about
+//! from the server.
+//!
+//! ## How messages are deleted
+//!
+//! When the message is deleted locally, its contents is removed and
+//! it is moved to the trash chat. This database entry is then used to
+//! track the Message-ID and corresponding IMAP folder and UID until
+//! the message is deleted from the server. Vice versa, when device
+//! deletes the message from the server, it removes IMAP folder and
+//! UID information, but keeps the message contents. When database
+//! entry is both moved to trash chat and does not contain UID
+//! information, it is deleted from the database, leaving no trace of
+//! the message.
+//!
+//! ## When messages are deleted
+//!
+//! Local deletion happens when the chatlist or chat is loaded. A
+//! `MsgsChanged` event is emitted when a message deletion is due, to
+//! make UI reload displayed messages and cause actual deletion.
+//!
+//! Server deletion happens by generating IMAP deletion jobs based on
+//! the database entries which are expired either according to their
+//! ephemeral message timers or global `delete_server_after` setting.
+
+use crate::chat::{lookup_by_contact_id, send_msg, ChatId};
+use crate::constants::{
+    Viewtype, DC_CHAT_ID_LAST_SPECIAL, DC_CHAT_ID_TRASH, DC_CONTACT_ID_DEVICE, DC_CONTACT_ID_SELF,
+};
+use crate::context::Context;
+use crate::dc_tools::time;
+use crate::error::{ensure, Error};
+use crate::events::Event;
+use crate::message::{Message, MessageState, MsgId};
+use crate::mimeparser::SystemMessage;
+use crate::sql;
+use crate::stock::StockMessage;
+use async_std::task;
+use serde::{Deserialize, Serialize};
+use std::convert::{TryFrom, TryInto};
+use std::num::ParseIntError;
+use std::str::FromStr;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+#[derive(Debug, PartialEq, Eq, Copy, Clone, Serialize, Deserialize)]
+pub enum Timer {
+    Disabled,
+    Enabled { duration: u32 },
+}
+
+impl Timer {
+    pub fn to_u32(self) -> u32 {
+        match self {
+            Self::Disabled => 0,
+            Self::Enabled { duration } => duration,
+        }
+    }
+
+    pub fn from_u32(duration: u32) -> Self {
+        if duration == 0 {
+            Self::Disabled
+        } else {
+            Self::Enabled { duration }
+        }
+    }
+}
+
+impl Default for Timer {
+    fn default() -> Self {
+        Self::Disabled
+    }
+}
+
+impl ToString for Timer {
+    fn to_string(&self) -> String {
+        self.to_u32().to_string()
+    }
+}
+
+impl FromStr for Timer {
+    type Err = ParseIntError;
+
+    fn from_str(input: &str) -> Result<Timer, ParseIntError> {
+        input.parse::<u32>().map(Self::from_u32)
+    }
+}
+
+impl rusqlite::types::ToSql for Timer {
+    fn to_sql(&self) -> rusqlite::Result<rusqlite::types::ToSqlOutput> {
+        let val = rusqlite::types::Value::Integer(match self {
+            Self::Disabled => 0,
+            Self::Enabled { duration } => i64::from(*duration),
+        });
+        let out = rusqlite::types::ToSqlOutput::Owned(val);
+        Ok(out)
+    }
+}
+
+impl rusqlite::types::FromSql for Timer {
+    fn column_result(value: rusqlite::types::ValueRef) -> rusqlite::types::FromSqlResult<Self> {
+        i64::column_result(value).and_then(|value| {
+            if value == 0 {
+                Ok(Self::Disabled)
+            } else if let Ok(duration) = u32::try_from(value) {
+                Ok(Self::Enabled { duration })
+            } else {
+                Err(rusqlite::types::FromSqlError::OutOfRange(value))
+            }
+        })
+    }
+}
+
+impl ChatId {
+    /// Get ephemeral message timer value in seconds.
+    pub async fn get_ephemeral_timer(self, context: &Context) -> Result<Timer, Error> {
+        let timer = context
+            .sql
+            .query_get_value_result(
+                "SELECT ephemeral_timer FROM chats WHERE id=?;",
+                paramsv![self],
+            )
+            .await?;
+        Ok(timer.unwrap_or_default())
+    }
+
+    /// Set ephemeral timer value without sending a message.
+    ///
+    /// Used when a message arrives indicating that someone else has
+    /// changed the timer value for a chat.
+    pub(crate) async fn inner_set_ephemeral_timer(
+        self,
+        context: &Context,
+        timer: Timer,
+    ) -> Result<(), Error> {
+        ensure!(!self.is_special(), "Invalid chat ID");
+
+        context
+            .sql
+            .execute(
+                "UPDATE chats
+             SET ephemeral_timer=?
+             WHERE id=?;",
+                paramsv![timer, self],
+            )
+            .await?;
+
+        context.emit_event(Event::ChatEphemeralTimerModified {
+            chat_id: self,
+            timer,
+        });
+        Ok(())
+    }
+
+    /// Set ephemeral message timer value in seconds.
+    ///
+    /// If timer value is 0, disable ephemeral message timer.
+    pub async fn set_ephemeral_timer(self, context: &Context, timer: Timer) -> Result<(), Error> {
+        if timer == self.get_ephemeral_timer(context).await? {
+            return Ok(());
+        }
+        self.inner_set_ephemeral_timer(context, timer).await?;
+        let mut msg = Message::new(Viewtype::Text);
+        msg.text = Some(stock_ephemeral_timer_changed(context, timer, DC_CONTACT_ID_SELF).await);
+        msg.param.set_cmd(SystemMessage::EphemeralTimerChanged);
+        if let Err(err) = send_msg(context, self, &mut msg).await {
+            error!(
+                context,
+                "Failed to send a message about ephemeral message timer change: {:?}", err
+            );
+        }
+        Ok(())
+    }
+}
+
+/// Returns a stock message saying that ephemeral timer is changed to `timer` by `from_id`.
+pub(crate) async fn stock_ephemeral_timer_changed(
+    context: &Context,
+    timer: Timer,
+    from_id: u32,
+) -> String {
+    let stock_message = match timer {
+        Timer::Disabled => StockMessage::MsgEphemeralTimerDisabled,
+        Timer::Enabled { duration } => match duration {
+            60 => StockMessage::MsgEphemeralTimerMinute,
+            3600 => StockMessage::MsgEphemeralTimerHour,
+            86400 => StockMessage::MsgEphemeralTimerDay,
+            604_800 => StockMessage::MsgEphemeralTimerWeek,
+            2_419_200 => StockMessage::MsgEphemeralTimerFourWeeks,
+            _ => StockMessage::MsgEphemeralTimerEnabled,
+        },
+    };
+
+    context
+        .stock_system_msg(stock_message, timer.to_string(), "", from_id)
+        .await
+}
+
+impl MsgId {
+    /// Returns ephemeral message timer value for the message.
+    pub(crate) async fn ephemeral_timer(self, context: &Context) -> crate::sql::Result<Timer> {
+        let res = match context
+            .sql
+            .query_get_value_result(
+                "SELECT ephemeral_timer FROM msgs WHERE id=?",
+                paramsv![self],
+            )
+            .await?
+        {
+            None | Some(0) => Timer::Disabled,
+            Some(duration) => Timer::Enabled { duration },
+        };
+        Ok(res)
+    }
+
+    /// Starts ephemeral message timer for the message if it is not started yet.
+    pub(crate) async fn start_ephemeral_timer(self, context: &Context) -> crate::sql::Result<()> {
+        if let Timer::Enabled { duration } = self.ephemeral_timer(context).await? {
+            let ephemeral_timestamp = time() + i64::from(duration);
+
+            context
+                .sql
+                .execute(
+                    "UPDATE msgs SET ephemeral_timestamp = ? \
+                WHERE (ephemeral_timestamp == 0 OR ephemeral_timestamp > ?) \
+                AND id = ?",
+                    paramsv![ephemeral_timestamp, ephemeral_timestamp, self],
+                )
+                .await?;
+            schedule_ephemeral_task(context).await;
+        }
+        Ok(())
+    }
+}
+
+/// Deletes messages which are expired according to
+/// `delete_device_after` setting or `ephemeral_timestamp` column.
+///
+/// Returns true if any message is deleted, so caller can emit
+/// MsgsChanged event. If nothing has been deleted, returns
+/// false. This function does not emit the MsgsChanged event itself,
+/// because it is also called when chatlist is reloaded, and emitting
+/// MsgsChanged there will cause infinite reload loop.
+pub(crate) async fn delete_expired_messages(context: &Context) -> Result<bool, Error> {
+    let mut updated = context
+        .sql
+        .execute(
+            "UPDATE msgs \
+             SET txt = 'DELETED', chat_id = ? \
+             WHERE \
+             ephemeral_timestamp != 0 \
+             AND ephemeral_timestamp < ? \
+             AND chat_id != ?",
+            paramsv![DC_CHAT_ID_TRASH, time(), DC_CHAT_ID_TRASH],
+        )
+        .await?
+        > 0;
+
+    if let Some(delete_device_after) = context.get_config_delete_device_after().await {
+        let self_chat_id = lookup_by_contact_id(context, DC_CONTACT_ID_SELF)
+            .await
+            .unwrap_or_default()
+            .0;
+        let device_chat_id = lookup_by_contact_id(context, DC_CONTACT_ID_DEVICE)
+            .await
+            .unwrap_or_default()
+            .0;
+
+        let threshold_timestamp = time() - delete_device_after;
+
+        // Delete expired messages
+        //
+        // Only update the rows that have to be updated, to avoid emitting
+        // unnecessary "chat modified" events.
+        let rows_modified = context
+            .sql
+            .execute(
+                "UPDATE msgs \
+             SET txt = 'DELETED', chat_id = ? \
+             WHERE timestamp < ? \
+             AND chat_id > ? \
+             AND chat_id != ? \
+             AND chat_id != ?",
+                paramsv![
+                    DC_CHAT_ID_TRASH,
+                    threshold_timestamp,
+                    DC_CHAT_ID_LAST_SPECIAL,
+                    self_chat_id,
+                    device_chat_id
+                ],
+            )
+            .await?;
+
+        updated |= rows_modified > 0;
+    }
+
+    schedule_ephemeral_task(context).await;
+    Ok(updated)
+}
+
+/// Schedule a task to emit MsgsChanged event when the next local
+/// deletion happens. Existing task is cancelled to make sure at most
+/// one such task is scheduled at a time.
+///
+/// UI is expected to reload the chatlist or the chat in response to
+/// MsgsChanged event, this will trigger actual deletion.
+///
+/// This takes into account only per-chat timeouts, because global device
+/// timeouts are at least one hour long and deletion is triggered often enough
+/// by user actions.
+pub async fn schedule_ephemeral_task(context: &Context) {
+    let ephemeral_timestamp: Option<i64> = match context
+        .sql
+        .query_get_value_result(
+            "SELECT ephemeral_timestamp \
+         FROM msgs \
+         WHERE ephemeral_timestamp != 0 \
+           AND chat_id != ? \
+         ORDER BY ephemeral_timestamp ASC \
+         LIMIT 1",
+            paramsv![DC_CHAT_ID_TRASH], // Trash contains already deleted messages, skip them
+        )
+        .await
+    {
+        Err(err) => {
+            warn!(context, "Can't calculate next ephemeral timeout: {}", err);
+            return;
+        }
+        Ok(ephemeral_timestamp) => ephemeral_timestamp,
+    };
+
+    // Cancel existing task, if any
+    if let Some(ephemeral_task) = context.ephemeral_task.write().await.take() {
+        ephemeral_task.cancel().await;
+    }
+
+    if let Some(ephemeral_timestamp) = ephemeral_timestamp {
+        let now = SystemTime::now();
+        let until = UNIX_EPOCH
+            + Duration::from_secs(ephemeral_timestamp.try_into().unwrap_or(u64::MAX))
+            + Duration::from_secs(1);
+
+        if let Ok(duration) = until.duration_since(now) {
+            // Schedule a task, ephemeral_timestamp is in the future
+            let context1 = context.clone();
+            let ephemeral_task = task::spawn(async move {
+                async_std::task::sleep(duration).await;
+                emit_event!(
+                    context1,
+                    Event::MsgsChanged {
+                        chat_id: ChatId::new(0),
+                        msg_id: MsgId::new(0)
+                    }
+                );
+            });
+            *context.ephemeral_task.write().await = Some(ephemeral_task);
+        } else {
+            // Emit event immediately
+            emit_event!(
+                context,
+                Event::MsgsChanged {
+                    chat_id: ChatId::new(0),
+                    msg_id: MsgId::new(0)
+                }
+            );
+        }
+    }
+}
+
+/// Returns ID of any expired message that should be deleted from the server.
+///
+/// It looks up the trash chat too, to find messages that are already
+/// deleted locally, but not deleted on the server.
+pub(crate) async fn load_imap_deletion_msgid(context: &Context) -> sql::Result<Option<MsgId>> {
+    let now = time();
+
+    let threshold_timestamp = match context.get_config_delete_server_after().await {
+        None => 0,
+        Some(delete_server_after) => now - delete_server_after,
+    };
+
+    context
+        .sql
+        .query_row_optional(
+            "SELECT id FROM msgs \
+         WHERE ( \
+         timestamp < ? \
+         OR (ephemeral_timestamp != 0 AND ephemeral_timestamp < ?) \
+         ) \
+         AND server_uid != 0 \
+         LIMIT 1",
+            paramsv![threshold_timestamp, now],
+            |row| row.get::<_, MsgId>(0),
+        )
+        .await
+}
+
+/// Start ephemeral timers for seen messages if they are not started
+/// yet.
+///
+/// It is possible that timers are not started due to a missing or
+/// failed `MsgId.start_ephemeral_timer()` call, either in the current
+/// or previous version of Delta Chat.
+///
+/// This function is supposed to be called in the background,
+/// e.g. from housekeeping task.
+pub(crate) async fn start_ephemeral_timers(context: &Context) -> sql::Result<()> {
+    context
+        .sql
+        .execute(
+            "UPDATE msgs \
+    SET ephemeral_timestamp = ? + ephemeral_timer \
+    WHERE ephemeral_timer > 0 \
+    AND ephemeral_timestamp = 0 \
+    AND state NOT IN (?, ?, ?)",
+            paramsv![
+                time(),
+                MessageState::InFresh,
+                MessageState::InNoticed,
+                MessageState::OutDraft
+            ],
+        )
+        .await?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::*;
+
+    #[async_std::test]
+    async fn test_stock_ephemeral_messages() {
+        let context = TestContext::new().await.ctx;
+
+        assert_eq!(
+            stock_ephemeral_timer_changed(&context, Timer::Disabled, DC_CONTACT_ID_SELF).await,
+            "Message deletion timer is disabled by me."
+        );
+
+        assert_eq!(
+            stock_ephemeral_timer_changed(&context, Timer::Disabled, 0).await,
+            "Message deletion timer is disabled."
+        );
+        assert_eq!(
+            stock_ephemeral_timer_changed(&context, Timer::Enabled { duration: 1 }, 0).await,
+            "Message deletion timer is set to 1 s."
+        );
+        assert_eq!(
+            stock_ephemeral_timer_changed(&context, Timer::Enabled { duration: 30 }, 0).await,
+            "Message deletion timer is set to 30 s."
+        );
+        assert_eq!(
+            stock_ephemeral_timer_changed(&context, Timer::Enabled { duration: 60 }, 0).await,
+            "Message deletion timer is set to 1 minute."
+        );
+        assert_eq!(
+            stock_ephemeral_timer_changed(&context, Timer::Enabled { duration: 60 * 60 }, 0).await,
+            "Message deletion timer is set to 1 hour."
+        );
+        assert_eq!(
+            stock_ephemeral_timer_changed(
+                &context,
+                Timer::Enabled {
+                    duration: 24 * 60 * 60
+                },
+                0
+            )
+            .await,
+            "Message deletion timer is set to 1 day."
+        );
+        assert_eq!(
+            stock_ephemeral_timer_changed(
+                &context,
+                Timer::Enabled {
+                    duration: 7 * 24 * 60 * 60
+                },
+                0
+            )
+            .await,
+            "Message deletion timer is set to 1 week."
+        );
+        assert_eq!(
+            stock_ephemeral_timer_changed(
+                &context,
+                Timer::Enabled {
+                    duration: 4 * 7 * 24 * 60 * 60
+                },
+                0
+            )
+            .await,
+            "Message deletion timer is set to 4 weeks."
+        );
+    }
+}
--- a/src/events.rs
+++ b/src/events.rs
@@ -5,6 +5,7 @@ use async_std::sync::{channel, Receiver, Sender, TrySendError};
 use strum::EnumProperty;

 use crate::chat::ChatId;
+use crate::ephemeral::Timer as EphemeralTimer;
 use crate::message::MsgId;

 #[derive(Debug)]
@@ -189,9 +190,19 @@ pub enum Event {
    /// Or the verify state of a chat has changed.
    /// See dc_set_chat_name(), dc_set_chat_profile_image(), dc_add_contact_to_chat()
    /// and dc_remove_contact_from_chat().
+    ///
+    /// This event does not include ephemeral timer modification, which
+    /// is a separate event.
    #[strum(props(id = "2020"))]
    ChatModified(ChatId),

+    /// Chat ephemeral timer changed.
+    #[strum(props(id = "2021"))]
+    ChatEphemeralTimerModified {
+        chat_id: ChatId,
+        timer: EphemeralTimer,
+    },
+
    /// Contact(s) created, renamed, blocked or deleted.
    ///
    /// @param data1 (int) If set, this is the contact_id of an added contact that should be selected.
--- a/src/headerdef.rs
+++ b/src/headerdef.rs
@@ -42,6 +42,7 @@ pub enum HeaderDef {
    SecureJoinFingerprint,
    SecureJoinInvitenumber,
    SecureJoinAuth,
+    EphemeralTimer,
    _TestHeader,
 }

--- a/src/imap/idle.rs
+++ b/src/imap/idle.rs
@@ -13,19 +13,19 @@ type Result<T> = std::result::Result<T, Error>;

 #[derive(Debug, thiserror::Error)]
 pub enum Error {
-    #[error("IMAP IDLE protocol failed to init/complete")]
+    #[error("IMAP IDLE protocol failed to init/complete: {0}")]
    IdleProtocolFailed(#[from] async_imap::error::Error),

-    #[error("IMAP IDLE protocol timed out")]
+    #[error("IMAP IDLE protocol timed out: {0}")]
    IdleTimeout(#[from] async_std::future::TimeoutError),

    #[error("IMAP server does not have IDLE capability")]
    IdleAbilityMissing,

-    #[error("IMAP select folder error")]
+    #[error("IMAP select folder error: {0}")]
    SelectFolderError(#[from] select_folder::Error),

-    #[error("Setup handle error")]
+    #[error("Setup handle error: {0}")]
    SetupHandleError(#[from] super::Error),
 }

@@ -48,11 +48,10 @@ impl Imap {

        self.select_folder(context, watch_folder.clone()).await?;

-        let session = self.session.take();
        let timeout = Duration::from_secs(23 * 60);
        let mut info = Default::default();

-        if let Some(session) = session {
+        if let Some(session) = self.session.take() {
            let mut handle = session.idle();
            if let Err(err) = handle.init().await {
                return Err(Error::IdleProtocolFailed(err));
@@ -65,68 +64,43 @@ impl Imap {
                Interrupt(InterruptInfo),
            }

-            if self.skip_next_idle_wait {
-                // interrupt_idle has happened before we
-                // provided self.interrupt
-                self.skip_next_idle_wait = false;
-                drop(idle_wait);
+            info!(context, "Idle entering wait-on-remote state");
+            let fut = idle_wait.map(|ev| ev.map(Event::IdleResponse)).race(async {
+                let probe_network = self.idle_interrupt.recv().await;
+
+                // cancel imap idle connection properly
                drop(interrupt);

-                info!(context, "Idle wait was skipped");
-            } else {
-                info!(context, "Idle entering wait-on-remote state");
-                let fut = idle_wait.map(|ev| ev.map(Event::IdleResponse)).race(
-                    self.idle_interrupt.recv().map(|probe_network| {
-                        Ok(Event::Interrupt(probe_network.unwrap_or_default()))
-                    }),
-                );
+                Ok(Event::Interrupt(probe_network.unwrap_or_default()))
+            });

-                match fut.await {
-                    Ok(Event::IdleResponse(IdleResponse::NewData(_))) => {
-                        info!(context, "Idle has NewData");
-                    }
-                    // TODO: idle_wait does not distinguish manual interrupts
-                    // from Timeouts if we would know it's a Timeout we could bail
-                    // directly and reconnect .
-                    Ok(Event::IdleResponse(IdleResponse::Timeout)) => {
-                        info!(context, "Idle-wait timeout or interruption");
-                    }
-                    Ok(Event::IdleResponse(IdleResponse::ManualInterrupt)) => {
-                        info!(context, "Idle wait was interrupted");
-                    }
-                    Ok(Event::Interrupt(i)) => {
-                        info = i;
-                        info!(context, "Idle wait was interrupted");
-                    }
-                    Err(err) => {
-                        warn!(context, "Idle wait errored: {:?}", err);
-                    }
+            match fut.await {
+                Ok(Event::IdleResponse(IdleResponse::NewData(_))) => {
+                    info!(context, "Idle has NewData");
+                }
+                Ok(Event::IdleResponse(IdleResponse::Timeout)) => {
+                    info!(context, "Idle-wait timeout or interruption");
+                }
+                Ok(Event::IdleResponse(IdleResponse::ManualInterrupt)) => {
+                    info!(context, "Idle wait was interrupted");
+                }
+                Ok(Event::Interrupt(i)) => {
+                    info = i;
+                    info!(context, "Idle wait was interrupted");
+                }
+                Err(err) => {
+                    warn!(context, "Idle wait errored: {:?}", err);
                }
            }

-            // if we can't properly terminate the idle
-            // protocol let's break the connection.
-            let res = handle
+            let session = handle
                .done()
                .timeout(Duration::from_secs(15))
                .await
-                .map_err(|err| {
-                    self.trigger_reconnect();
-                    Error::IdleTimeout(err)
-                })?;
-
-            match res {
-                Ok(session) => {
-                    self.session = Some(Session { inner: session });
-                }
-                Err(err) => {
-                    // if we cannot terminate IDLE it probably
-                    // means that we waited long (with idle_wait)
-                    // but the network went away/changed
-                    self.trigger_reconnect();
-                    return Err(Error::IdleProtocolFailed(err));
-                }
-            }
+                .map_err(Error::IdleTimeout)??;
+            self.session = Some(Session { inner: session });
+        } else {
+            warn!(context, "Attempted to idle without a session");
        }

        Ok(info)
@@ -148,73 +122,66 @@ impl Imap {
            return self.idle_interrupt.recv().await.unwrap_or_default();
        }

-        let mut info: InterruptInfo = Default::default();
-        if self.skip_next_idle_wait {
-            // interrupt_idle has happened before we
-            // provided self.interrupt
-            self.skip_next_idle_wait = false;
-            info!(context, "fake-idle wait was skipped");
-        } else {
-            // check every minute if there are new messages
-            // TODO: grow sleep durations / make them more flexible
-            let mut interval = async_std::stream::interval(Duration::from_secs(60));
+        // check every minute if there are new messages
+        // TODO: grow sleep durations / make them more flexible
+        let mut interval = async_std::stream::interval(Duration::from_secs(60));

-            enum Event {
-                Tick,
-                Interrupt(InterruptInfo),
-            }
-            // loop until we are interrupted or if we fetched something
-            info =
-                loop {
-                    use futures::future::FutureExt;
-                    match interval
-                        .next()
-                        .map(|_| Event::Tick)
-                        .race(self.idle_interrupt.recv().map(|probe_network| {
-                            Event::Interrupt(probe_network.unwrap_or_default())
-                        }))
-                        .await
-                    {
-                        Event::Tick => {
-                            // try to connect with proper login params
-                            // (setup_handle_if_needed might not know about them if we
-                            // never successfully connected)
-                            if let Err(err) = self.connect_configured(context).await {
-                                warn!(context, "fake_idle: could not connect: {}", err);
-                                continue;
-                            }
-                            if self.config.can_idle {
-                                // we only fake-idled because network was gone during IDLE, probably
-                                break InterruptInfo::new(false, None);
-                            }
-                            info!(context, "fake_idle is connected");
-                            // we are connected, let's see if fetching messages results
-                            // in anything.  If so, we behave as if IDLE had data but
-                            // will have already fetched the messages so perform_*_fetch
-                            // will not find any new.
+        enum Event {
+            Tick,
+            Interrupt(InterruptInfo),
+        }
+        // loop until we are interrupted or if we fetched something
+        let info = loop {
+            use futures::future::FutureExt;
+            match interval
+                .next()
+                .map(|_| Event::Tick)
+                .race(
+                    self.idle_interrupt
+                        .recv()
+                        .map(|probe_network| Event::Interrupt(probe_network.unwrap_or_default())),
+                )
+                .await
+            {
+                Event::Tick => {
+                    // try to connect with proper login params
+                    // (setup_handle_if_needed might not know about them if we
+                    // never successfully connected)
+                    if let Err(err) = self.connect_configured(context).await {
+                        warn!(context, "fake_idle: could not connect: {}", err);
+                        continue;
+                    }
+                    if self.config.can_idle {
+                        // we only fake-idled because network was gone during IDLE, probably
+                        break InterruptInfo::new(false, None);
+                    }
+                    info!(context, "fake_idle is connected");
+                    // we are connected, let's see if fetching messages results
+                    // in anything.  If so, we behave as if IDLE had data but
+                    // will have already fetched the messages so perform_*_fetch
+                    // will not find any new.

-                            if let Some(ref watch_folder) = watch_folder {
-                                match self.fetch_new_messages(context, watch_folder).await {
-                                    Ok(res) => {
-                                        info!(context, "fetch_new_messages returned {:?}", res);
-                                        if res {
-                                            break InterruptInfo::new(false, None);
-                                        }
-                                    }
-                                    Err(err) => {
-                                        error!(context, "could not fetch from folder: {}", err);
-                                        self.trigger_reconnect()
-                                    }
+                    if let Some(ref watch_folder) = watch_folder {
+                        match self.fetch_new_messages(context, watch_folder).await {
+                            Ok(res) => {
+                                info!(context, "fetch_new_messages returned {:?}", res);
+                                if res {
+                                    break InterruptInfo::new(false, None);
                                }
                            }
-                        }
-                        Event::Interrupt(info) => {
-                            // Interrupt
-                            break info;
+                            Err(err) => {
+                                error!(context, "could not fetch from folder: {}", err);
+                                self.trigger_reconnect()
+                            }
                        }
                    }
-                };
-        }
+                }
+                Event::Interrupt(info) => {
+                    // Interrupt
+                    break info;
+                }
+            }
+        };

        info!(
            context,
--- a/src/imap/mod.rs
+++ b/src/imap/mod.rs
@@ -3,8 +3,6 @@
 //! uses [async-email/async-imap](https://github.com/async-email/async-imap)
 //! to implement connect, fetch, delete functionality with standard IMAP servers.

-#![forbid(clippy::indexing_slicing)]
-
 use std::collections::BTreeMap;

 use async_imap::{
@@ -25,12 +23,12 @@ use crate::events::Event;
 use crate::headerdef::{HeaderDef, HeaderDefMap};
 use crate::job::{self, Action};
 use crate::login_param::{CertificateChecks, LoginParam};
-use crate::message::{self, update_server_uid};
+use crate::message::{self, update_server_uid, MessageState};
 use crate::mimeparser;
 use crate::oauth2::dc_get_oauth2_access_token;
 use crate::param::Params;
 use crate::provider::get_provider_info;
-use crate::{scheduler::InterruptInfo, stock::StockMessage};
+use crate::{chat, scheduler::InterruptInfo, stock::StockMessage};

 mod client;
 mod idle;
@@ -38,6 +36,7 @@ pub mod select_folder;
 mod session;

 use client::Client;
+use message::Message;
 use session::Session;

 type Result<T> = std::result::Result<T, Error>;
@@ -117,8 +116,8 @@ pub struct Imap {
    session: Option<Session>,
    connected: bool,
    interrupt: Option<stop_token::StopSource>,
-    skip_next_idle_wait: bool,
    should_reconnect: bool,
+    login_failed_once: bool,
 }

 #[derive(Debug)]
@@ -191,8 +190,8 @@ impl Imap {
            session: Default::default(),
            connected: Default::default(),
            interrupt: Default::default(),
-            skip_next_idle_wait: Default::default(),
            should_reconnect: Default::default(),
+            login_failed_once: Default::default(),
        }
    }

@@ -297,18 +296,40 @@ impl Imap {
                // needs to be set here to ensure it is set on reconnects.
                self.connected = true;
                self.session = Some(session);
+                self.login_failed_once = false;
                Ok(())
            }
+
            Err((err, _)) => {
                let imap_user = self.config.imap_user.to_owned();
                let message = context
                    .stock_string_repl_str(StockMessage::CannotLogin, &imap_user)
                    .await;

-                emit_event!(
-                    context,
-                    Event::ErrorNetwork(format!("{} ({})", message, err))
-                );
+                warn!(context, "{} ({})", message, err);
+                emit_event!(context, Event::ErrorNetwork(message.clone()));
+
+                let lock = context.wrong_pw_warning_mutex.lock().await;
+                if self.login_failed_once
+                    && context.get_config_bool(Config::NotifyAboutWrongPw).await
+                {
+                    if let Err(e) = context.set_config(Config::NotifyAboutWrongPw, None).await {
+                        warn!(context, "{}", e);
+                    }
+                    drop(lock);
+
+                    let mut msg = Message::new(Viewtype::Text);
+                    msg.text = Some(message);
+                    if let Err(e) =
+                        chat::add_device_msg_with_importance(context, None, Some(&mut msg), true)
+                            .await
+                    {
+                        warn!(context, "{}", e);
+                    }
+                } else {
+                    self.login_failed_once = true;
+                }
+
                self.trigger_reconnect();
                Err(Error::LoginFailed(format!("cannot login as {}", imap_user)))
            }
@@ -783,7 +804,6 @@ impl Imap {
        let mut last_uid = None;
        let mut count = 0;

-        let mut tasks = Vec::with_capacity(server_uids.len());
        while let Some(Ok(msg)) = msgs.next().await {
            let server_uid = msg.uid.unwrap_or_default();

@@ -803,31 +823,17 @@ impl Imap {
            let context = context.clone();
            let folder = folder.clone();

-            let task = async_std::task::spawn(async move {
-                // safe, as we checked above that there is a body.
-                let body = msg.body().unwrap();
-                let is_seen = msg.flags().any(|flag| flag == Flag::Seen);
+            // safe, as we checked above that there is a body.
+            let body = msg.body().unwrap();
+            let is_seen = msg.flags().any(|flag| flag == Flag::Seen);

-                match dc_receive_imf(&context, &body, &folder, server_uid, is_seen).await {
-                    Ok(_) => Some(server_uid),
-                    Err(err) => {
-                        warn!(context, "dc_receive_imf error: {}", err);
-                        None
-                    }
-                }
-            });
-            tasks.push(task);
-        }
-
-        for task in futures::future::join_all(tasks).await {
-            match task {
-                Some(uid) => {
-                    last_uid = Some(uid);
-                }
-                None => {
+            match dc_receive_imf(&context, &body, &folder, server_uid, is_seen).await {
+                Ok(_) => last_uid = Some(server_uid),
+                Err(err) => {
+                    warn!(context, "dc_receive_imf error: {}", err);
                    read_errors += 1;
                }
-            }
+            };
        }

        if count != server_uids.len() {
@@ -1360,14 +1366,26 @@ async fn precheck_imf(
            let delete_server_after = context.get_config_delete_server_after().await;

            if delete_server_after != Some(0) {
-                context
-                    .do_heuristics_moves(server_folder.as_ref(), msg_id)
+                if msg_id
+                    .needs_move(context, server_folder)
+                    .await
+                    .unwrap_or_default()
+                {
+                    // If the bcc-self message is not moved, directly
+                    // add MarkSeen job, otherwise MarkSeen job is
+                    // added after the Move Job completed.
+                    job::add(
+                        context,
+                        job::Job::new(Action::MoveMsg, msg_id.to_u32(), Params::new(), 0),
+                    )
                    .await;
-                job::add(
-                    context,
-                    job::Job::new(Action::MarkseenMsgOnImap, msg_id.to_u32(), Params::new(), 0),
-                )
-                .await;
+                } else {
+                    job::add(
+                        context,
+                        job::Job::new(Action::MarkseenMsgOnImap, msg_id.to_u32(), Params::new(), 0),
+                    )
+                    .await;
+                }
            }
        } else if old_server_folder != server_folder {
            info!(
@@ -1402,6 +1420,13 @@ async fn precheck_imf(

        if old_server_folder != server_folder || old_server_uid != server_uid {
            update_server_uid(context, rfc724_mid, server_folder, server_uid).await;
+            if let Ok(MessageState::InSeen) = msg_id.get_state(context).await {
+                job::add(
+                    context,
+                    job::Job::new(Action::MarkseenMsgOnImap, msg_id.to_u32(), Params::new(), 0),
+                )
+                .await;
+            };
            context
                .interrupt_inbox(InterruptInfo::new(false, Some(msg_id)))
                .await;
--- a/src/imap/select_folder.rs
+++ b/src/imap/select_folder.rs
@@ -51,6 +51,14 @@ impl Imap {
        Ok(())
    }

+    /// Issues a CLOSE command if selected folder needs expunge.
+    pub(crate) async fn maybe_close_folder(&mut self, context: &Context) -> Result<()> {
+        if self.config.selected_folder_needs_expunge {
+            self.close_folder(context).await?;
+        }
+        Ok(())
+    }
+
    /// select a folder, possibly update uid_validity and, if needed,
    /// expunge the folder to remove delete-marked messages.
    pub(super) async fn select_folder<S: AsRef<str>>(
@@ -76,10 +84,7 @@ impl Imap {
        }

        // deselect existing folder, if needed (it's also done implicitly by SELECT, however, without EXPUNGE then)
-        let needs_expunge = { self.config.selected_folder_needs_expunge };
-        if needs_expunge {
-            self.close_folder(context).await?;
-        }
+        self.maybe_close_folder(context).await?;

        // select new folder
        if let Some(ref folder) = folder {
--- a/src/imex.rs
+++ b/src/imex.rs
@@ -178,10 +178,11 @@ async fn do_initiate_key_transfer(context: &Context) -> Result<String> {
 ///
 /// The `passphrase` must be at least 2 characters long.
 pub async fn render_setup_file(context: &Context, passphrase: &str) -> Result<String> {
-    ensure!(
-        passphrase.len() >= 2,
-        "Passphrase must be at least 2 chars long."
-    );
+    let passphrase_begin = if let Some(passphrase_begin) = passphrase.get(..2) {
+        passphrase_begin
+    } else {
+        bail!("Passphrase must be at least 2 chars long.");
+    };
    let private_key = SignedSecretKey::load_self(context).await?;
    let ac_headers = match context.get_config_bool(Config::E2eeEnabled).await {
        false => None,
@@ -196,7 +197,7 @@ pub async fn render_setup_file(context: &Context, passphrase: &str) -> Result<St
            "Passphrase-Format: numeric9x4\r\n",
            "Passphrase-Begin: {}"
        ),
-        &passphrase[..2]
+        passphrase_begin
    );
    let pgp_msg = encr.replace("-----BEGIN PGP MESSAGE-----", &replacement);

@@ -776,9 +777,9 @@ mod tests {

    #[async_std::test]
    async fn test_render_setup_file() {
-        let t = test_context().await;
+        let t = TestContext::new().await;

-        configure_alice_keypair(&t.ctx).await;
+        t.configure_alice().await;
        let msg = render_setup_file(&t.ctx, "hello").await.unwrap();
        println!("{}", &msg);
        // Check some substrings, indicating things got substituted.
@@ -795,12 +796,12 @@ mod tests {

    #[async_std::test]
    async fn test_render_setup_file_newline_replace() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        t.ctx
            .set_stock_translation(StockMessage::AcSetupMsgBody, "hello\r\nthere".to_string())
            .await
            .unwrap();
-        configure_alice_keypair(&t.ctx).await;
+        t.configure_alice().await;
        let msg = render_setup_file(&t.ctx, "pw").await.unwrap();
        println!("{}", &msg);
        assert!(msg.contains("<p>hello<br>there</p>"));
@@ -808,7 +809,7 @@ mod tests {

    #[async_std::test]
    async fn test_create_setup_code() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let setupcode = create_setup_code(&t.ctx);
        assert_eq!(setupcode.len(), 44);
        assert_eq!(setupcode.chars().nth(4).unwrap(), '-');
@@ -823,7 +824,7 @@ mod tests {

    #[async_std::test]
    async fn test_export_key_to_asc_file() {
-        let context = dummy_context().await;
+        let context = TestContext::new().await;
        let key = alice_keypair().public;
        let blobdir = "$BLOBDIR";
        assert!(export_key_to_asc_file(&context.ctx, blobdir, None, &key)
--- a/src/job.rs
+++ b/src/job.rs
@@ -21,6 +21,7 @@ use crate::constants::*;
 use crate::contact::Contact;
 use crate::context::Context;
 use crate::dc_tools::*;
+use crate::ephemeral::load_imap_deletion_msgid;
 use crate::error::{bail, ensure, format_err, Error, Result};
 use crate::events::Event;
 use crate::imap::*;
@@ -638,7 +639,21 @@ impl Job {
        let msg = job_try!(Message::load_from_db(context, MsgId::new(self.foreign_id)).await);

        let folder = msg.server_folder.as_ref().unwrap();
-        match imap.set_seen(context, folder, msg.server_uid).await {
+
+        let result = if msg.server_uid == 0 {
+            // The message is moved or deleted by us.
+            //
+            // Do not call set_seen with zero UID, as it will return
+            // ImapActionResult::RetryLater, but we do not want to
+            // retry. If the message was moved, we will create another
+            // job to mark the message as seen later. If it was
+            // deleted, there is nothing to do.
+            ImapActionResult::Failed
+        } else {
+            imap.set_seen(context, folder, msg.server_uid).await
+        };
+
+        match result {
            ImapActionResult::RetryLater => Status::RetryLater,
            ImapActionResult::AlreadyDone => Status::Finished(Ok(())),
            ImapActionResult::Success | ImapActionResult::Failed => {
@@ -828,25 +843,6 @@ pub(crate) enum Connection<'a> {
    Smtp(&'a mut Smtp),
 }

-async fn load_imap_deletion_msgid(context: &Context) -> sql::Result<Option<MsgId>> {
-    if let Some(delete_server_after) = context.get_config_delete_server_after().await {
-        let threshold_timestamp = time() - delete_server_after;
-
-        context
-            .sql
-            .query_row_optional(
-                "SELECT id FROM msgs \
-             WHERE timestamp < ? \
-             AND server_uid != 0",
-                paramsv![threshold_timestamp],
-                |row| row.get::<_, MsgId>(0),
-            )
-            .await
-    } else {
-        Ok(None)
-    }
-}
-
 async fn load_imap_deletion_job(context: &Context) -> sql::Result<Option<Job>> {
    let res = if let Some(msg_id) = load_imap_deletion_msgid(context).await? {
        Some(Job::new(
@@ -1209,7 +1205,7 @@ mod tests {
        // We want to ensure that loading jobs skips over jobs which
        // fails to load from the database instead of failing to load
        // all jobs.
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        insert_job(&t.ctx, -1).await; // This can not be loaded into Job struct.
        let jobs = load_next(
            &t.ctx,
@@ -1231,7 +1227,7 @@ mod tests {

    #[async_std::test]
    async fn test_load_next_job_one() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;

        insert_job(&t.ctx, 1).await;

--- a/src/key.rs
+++ b/src/key.rs
@@ -247,7 +247,7 @@ async fn generate_keypair(context: &Context) -> Result<KeyPair> {
            secret: SignedSecretKey::from_slice(&sec_bytes)?,
        }),
        Err(sql::Error::Sql(rusqlite::Error::QueryReturnedNoRows)) => {
-            let start = std::time::Instant::now();
+            let start = std::time::SystemTime::now();
            let keytype = KeyGenType::from_i32(context.get_config_int(Config::KeyGenType).await)
                .unwrap_or_default();
            info!(context, "Generating keypair with type {}", keytype);
@@ -258,7 +258,7 @@ async fn generate_keypair(context: &Context) -> Result<KeyPair> {
            info!(
                context,
                "Keypair generated in {:.3}s.",
-                start.elapsed().as_secs()
+                start.elapsed().unwrap_or_default().as_secs()
            );
            Ok(keypair)
        }
@@ -550,8 +550,8 @@ i8pcjGO+IZffvyZJVRWfVooBJmWWbPB1pueo3tx8w3+fcuzpxz+RLFKaPyqXO+dD
    #[async_std::test]
    async fn test_load_self_existing() {
        let alice = alice_keypair();
-        let t = dummy_context().await;
-        configure_alice_keypair(&t.ctx).await;
+        let t = TestContext::new().await;
+        t.configure_alice().await;
        let pubkey = SignedPublicKey::load_self(&t.ctx).await.unwrap();
        assert_eq!(alice.public, pubkey);
        let seckey = SignedSecretKey::load_self(&t.ctx).await.unwrap();
@@ -560,7 +560,7 @@ i8pcjGO+IZffvyZJVRWfVooBJmWWbPB1pueo3tx8w3+fcuzpxz+RLFKaPyqXO+dD

    #[async_std::test]
    async fn test_load_self_generate_public() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        t.ctx
            .set_config(Config::ConfiguredAddr, Some("alice@example.com"))
            .await
@@ -571,7 +571,7 @@ i8pcjGO+IZffvyZJVRWfVooBJmWWbPB1pueo3tx8w3+fcuzpxz+RLFKaPyqXO+dD

    #[async_std::test]
    async fn test_load_self_generate_secret() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        t.ctx
            .set_config(Config::ConfiguredAddr, Some("alice@example.com"))
            .await
@@ -584,7 +584,7 @@ i8pcjGO+IZffvyZJVRWfVooBJmWWbPB1pueo3tx8w3+fcuzpxz+RLFKaPyqXO+dD
    async fn test_load_self_generate_concurrent() {
        use std::thread;

-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        t.ctx
            .set_config(Config::ConfiguredAddr, Some("alice@example.com"))
            .await
@@ -611,7 +611,7 @@ i8pcjGO+IZffvyZJVRWfVooBJmWWbPB1pueo3tx8w3+fcuzpxz+RLFKaPyqXO+dD
    async fn test_save_self_key_twice() {
        // Saving the same key twice should result in only one row in
        // the keypairs table.
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let ctx = Arc::new(t.ctx);

        let ctx1 = ctx.clone();
--- a/src/keyring.rs
+++ b/src/keyring.rs
@@ -79,8 +79,8 @@ mod tests {
    #[async_std::test]
    async fn test_keyring_load_self() {
        // new_self() implies load_self()
-        let t = dummy_context().await;
-        configure_alice_keypair(&t.ctx).await;
+        let t = TestContext::new().await;
+        t.configure_alice().await;
        let alice = alice_keypair();

        let pub_ring: Keyring<SignedPublicKey> = Keyring::new_self(&t.ctx).await.unwrap();
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,5 +1,10 @@
 #![forbid(unsafe_code)]
-#![deny(clippy::correctness, missing_debug_implementations, clippy::all)]
+#![deny(
+    clippy::correctness,
+    missing_debug_implementations,
+    clippy::all,
+    clippy::indexing_slicing
+)]
 #![allow(clippy::match_bool)]

 #[macro_use]
@@ -43,6 +48,7 @@ pub mod constants;
 pub mod contact;
 pub mod context;
 mod e2ee;
+pub mod ephemeral;
 mod imap;
 pub mod imex;
 mod scheduler;
--- a/src/location.rs
+++ b/src/location.rs
@@ -724,11 +724,11 @@ pub(crate) async fn job_maybe_send_locations_ended(
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::test_utils::dummy_context;
+    use crate::test_utils::TestContext;

    #[async_std::test]
    async fn test_kml_parse() {
-        let context = dummy_context().await;
+        let context = TestContext::new().await;

        let xml =
            b"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<kml xmlns=\"http://www.opengis.net/kml/2.2\">\n<Document addr=\"user@example.org\">\n<Placemark><Timestamp><when>2019-03-06T21:09:57Z</when></Timestamp><Point><coordinates accuracy=\"32.000000\">9.423110,53.790302</coordinates></Point></Placemark>\n<PlaceMARK>\n<Timestamp><WHEN > \n\t2018-12-13T22:11:12Z\t</WHEN></Timestamp><Point><coordinates aCCuracy=\"2.500000\"> 19.423110 \t , \n 63.790302\n </coordinates></Point></PlaceMARK>\n</Document>\n</kml>";
--- a/src/message.rs
+++ b/src/message.rs
@@ -6,6 +6,7 @@ use lazy_static::lazy_static;
 use serde::{Deserialize, Serialize};

 use crate::chat::{self, Chat, ChatId};
+use crate::config::Config;
 use crate::constants::*;
 use crate::contact::*;
 use crate::context::*;
@@ -68,18 +69,38 @@ impl MsgId {
        self.0 == 0
    }

-    /// Whether the message ID is the special marker1 marker.
-    ///
-    /// See the docs of the `dc_get_chat_msgs` C API for details.
-    pub fn is_marker1(self) -> bool {
-        self.0 == DC_MSG_ID_MARKER1
+    /// Returns message state.
+    pub async fn get_state(self, context: &Context) -> crate::sql::Result<MessageState> {
+        let result = context
+            .sql
+            .query_get_value_result("SELECT state FROM msgs WHERE id=?", paramsv![self])
+            .await?
+            .unwrap_or_default();
+        Ok(result)
    }

-    /// Whether the message ID is the special day marker.
-    ///
-    /// See the docs of the `dc_get_chat_msgs` C API for details.
-    pub fn is_daymarker(self) -> bool {
-        self.0 == DC_MSG_ID_DAYMARKER
+    /// Returns true if the message needs to be moved from `folder`.
+    pub async fn needs_move(self, context: &Context, folder: &str) -> Result<bool, Error> {
+        if !context.get_config_bool(Config::MvboxMove).await {
+            return Ok(false);
+        }
+
+        if context.is_mvbox(folder).await {
+            return Ok(false);
+        }
+
+        let msg = Message::load_from_db(context, self).await?;
+
+        if msg.is_setupmessage() {
+            // do not move setup messages;
+            // there may be a non-delta device that wants to handle it
+            return Ok(false);
+        }
+
+        match msg.is_dc_message {
+            MessengerMessage::No => Ok(false),
+            MessengerMessage::Yes | MessengerMessage::Reply => Ok(true),
+        }
    }

    /// Put message into trash chat and delete message text.
@@ -143,16 +164,7 @@ impl MsgId {

 impl std::fmt::Display for MsgId {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        // Would be nice if we could use match here, but no computed values in ranges.
-        if self.0 == DC_MSG_ID_MARKER1 {
-            write!(f, "Msg#Marker1")
-        } else if self.0 == DC_MSG_ID_DAYMARKER {
-            write!(f, "Msg#DayMarker")
-        } else if self.0 <= DC_MSG_ID_LAST_SPECIAL {
-            write!(f, "Msg#UnknownSpecial")
-        } else {
-            write!(f, "Msg#{}", self.0)
-        }
+        write!(f, "Msg#{}", self.0)
    }
 }

@@ -246,6 +258,8 @@ pub struct Message {
    pub(crate) timestamp_sort: i64,
    pub(crate) timestamp_sent: i64,
    pub(crate) timestamp_rcvd: i64,
+    pub(crate) ephemeral_timer: u32,
+    pub(crate) ephemeral_timestamp: i64,
    pub(crate) text: Option<String>,
    pub(crate) rfc724_mid: String,
    pub(crate) in_reply_to: Option<String>,
@@ -288,6 +302,8 @@ impl Message {
                    "    m.timestamp AS timestamp,",
                    "    m.timestamp_sent AS timestamp_sent,",
                    "    m.timestamp_rcvd AS timestamp_rcvd,",
+                    "    m.ephemeral_timer AS ephemeral_timer,",
+                    "    m.ephemeral_timestamp AS ephemeral_timestamp,",
                    "    m.type AS type,",
                    "    m.state AS state,",
                    "    m.error AS error,",
@@ -316,6 +332,8 @@ impl Message {
                    msg.timestamp_sort = row.get("timestamp")?;
                    msg.timestamp_sent = row.get("timestamp_sent")?;
                    msg.timestamp_rcvd = row.get("timestamp_rcvd")?;
+                    msg.ephemeral_timer = row.get("ephemeral_timer")?;
+                    msg.ephemeral_timestamp = row.get("ephemeral_timestamp")?;
                    msg.viewtype = row.get("type")?;
                    msg.state = row.get("state")?;
                    msg.error = row.get("error")?;
@@ -510,6 +528,14 @@ impl Message {
        self.param.get_int(Param::GuaranteeE2ee).unwrap_or_default() != 0
    }

+    pub fn get_ephemeral_timer(&self) -> u32 {
+        self.ephemeral_timer
+    }
+
+    pub fn get_ephemeral_timestamp(&self) -> i64 {
+        self.ephemeral_timestamp
+    }
+
    pub async fn get_summary(&mut self, context: &Context, chat: Option<&Chat>) -> Lot {
        let mut ret = Lot::new();

@@ -891,6 +917,17 @@ pub async fn get_msg_info(context: &Context, msg_id: MsgId) -> String {
        ret += "\n";
    }

+    if msg.ephemeral_timer != 0 {
+        ret += &format!("Ephemeral timer: {}\n", msg.ephemeral_timer);
+    }
+
+    if msg.ephemeral_timestamp != 0 {
+        ret += &format!(
+            "Expires: {}\n",
+            dc_timestamp_to_str(msg.ephemeral_timestamp)
+        );
+    }
+
    if msg.from_id == DC_CONTACT_ID_INFO || msg.to_id == DC_CONTACT_ID_INFO {
        // device-internal message, no further details needed
        return ret;
@@ -1096,6 +1133,14 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> bool {
    let mut send_event = false;

    for (id, curr_state, curr_blocked) in msgs.into_iter() {
+        if let Err(err) = id.start_ephemeral_timer(context).await {
+            error!(
+                context,
+                "Failed to start ephemeral timer for message {}: {}", id, err
+            );
+            continue;
+        }
+
        if curr_blocked == Blocked::Not {
            if curr_state == MessageState::InFresh || curr_state == MessageState::InNoticed {
                update_msg_state(context, id, MessageState::InSeen).await;
@@ -1152,7 +1197,7 @@ pub async fn star_msgs(context: &Context, msg_ids: Vec<MsgId>, star: bool) -> bo
        .is_ok()
 }

-/// Returns a summary test.
+/// Returns a summary text.
 pub async fn get_summarytext_by_raw(
    viewtype: Viewtype,
    text: Option<impl AsRef<str>>,
@@ -1293,7 +1338,7 @@ pub async fn handle_mdn(
    rfc724_mid: &str,
    timestamp_sent: i64,
 ) -> Option<(ChatId, MsgId)> {
-    if from_id <= DC_MSG_ID_LAST_SPECIAL || rfc724_mid.is_empty() {
+    if from_id <= DC_CONTACT_ID_LAST_SPECIAL || rfc724_mid.is_empty() {
        return None;
    }

@@ -1645,7 +1690,7 @@ mod tests {
    async fn test_prepare_message_and_send() {
        use crate::config::Config;

-        let d = test::dummy_context().await;
+        let d = test::TestContext::new().await;
        let ctx = &d.ctx;

        let contact = Contact::create(ctx, "", "dest@example.com")
@@ -1669,7 +1714,7 @@ mod tests {

    #[async_std::test]
    async fn test_get_summarytext_by_raw() {
-        let d = test::dummy_context().await;
+        let d = test::TestContext::new().await;
        let ctx = &d.ctx;

        let some_text = Some("bla bla".to_string());
--- a/src/mimefactory.rs
+++ b/src/mimefactory.rs
@@ -9,6 +9,7 @@ use crate::contact::*;
 use crate::context::{get_version_str, Context};
 use crate::dc_tools::*;
 use crate::e2ee::*;
+use crate::ephemeral::Timer as EphemeralTimer;
 use crate::error::{bail, ensure, format_err, Error};
 use crate::location;
 use crate::message::{self, Message};
@@ -498,7 +499,16 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
        let e2ee_guaranteed = self.is_e2ee_guaranteed();
        let encrypt_helper = EncryptHelper::new(self.context).await?;

-        let subject = encode_words(&subject_str);
+        let subject = if subject_str
+            .chars()
+            .all(|c| c.is_ascii_alphanumeric() || c == ' ')
+        // We do not use needs_encoding() here because needs_encoding() returns true if the string contains a space
+        // but we do not want to encode all subjects just because they contain a space.
+        {
+            subject_str
+        } else {
+            encode_words(&subject_str)
+        };

        let mut message = match self.loaded {
            Loaded::Message { .. } => {
@@ -526,6 +536,14 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
            Loaded::MDN { .. } => dc_create_outgoing_rfc724_mid(None, &self.from_addr),
        };

+        let ephemeral_timer = self.msg.chat_id.get_ephemeral_timer(self.context).await?;
+        if let EphemeralTimer::Enabled { duration } = ephemeral_timer {
+            protected_headers.push(Header::new(
+                "Ephemeral-Timer".to_string(),
+                duration.to_string(),
+            ));
+        }
+
        // we could also store the message-id in the protected headers
        // which would probably help to survive providers like
        // Outlook.com or hotmail which mangle the Message-ID.
@@ -776,6 +794,26 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
                    "location-streaming-enabled".into(),
                ));
            }
+            SystemMessage::EphemeralTimerChanged => {
+                protected_headers.push(Header::new(
+                    "Chat-Content".to_string(),
+                    "ephemeral-timer-changed".to_string(),
+                ));
+            }
+            SystemMessage::LocationOnly => {
+                // This should prevent automatic replies,
+                // such as non-delivery reports.
+                //
+                // See https://tools.ietf.org/html/rfc3834
+                //
+                // Adding this header without encryption leaks some
+                // information about the message contents, but it can
+                // already be easily guessed from message timing and size.
+                unprotected_headers.push(Header::new(
+                    "Auto-Submitted".to_string(),
+                    "auto-generated".to_string(),
+                ));
+            }
            SystemMessage::AutocryptSetupMessage => {
                unprotected_headers
                    .push(Header::new("Autocrypt-Setup-Message".into(), "v1".into()));
@@ -1210,7 +1248,6 @@ mod tests {
    use crate::chatlist::Chatlist;
    use crate::dc_receive_imf::dc_receive_imf;
    use crate::mimeparser::*;
-    use crate::test_utils::configured_offline_context;
    use crate::test_utils::TestContext;

    #[test]
@@ -1300,10 +1337,10 @@ mod tests {
        // 1.: Receive a mail from an MUA or Delta Chat
        assert_eq!(
            msg_to_subject_str(
-                b"From: Bob <bob@example.org>\n\
-                To: alice@example.org\n\
+                b"From: Bob <bob@example.com>\n\
+                To: alice@example.com\n\
                Subject: Antw: Chat: hello\n\
-                Message-ID: <2222@example.org>\n\
+                Message-ID: <2222@example.com>\n\
                Date: Sun, 22 Mar 2020 22:37:56 +0000\n\
                \n\
                hello\n"
@@ -1314,10 +1351,10 @@ mod tests {

        assert_eq!(
            msg_to_subject_str(
-                b"From: Bob <bob@example.org>\n\
-                To: alice@example.org\n\
+                b"From: Bob <bob@example.com>\n\
+                To: alice@example.com\n\
                Subject: Infos: 42\n\
-                Message-ID: <2222@example.org>\n\
+                Message-ID: <2222@example.com>\n\
                Date: Sun, 22 Mar 2020 22:37:56 +0000\n\
                \n\
                hello\n"
@@ -1329,11 +1366,11 @@ mod tests {
        // 2. Receive a message from Delta Chat when we did not send any messages before
        assert_eq!(
            msg_to_subject_str(
-                b"From: Charlie <charlie@example.org>\n\
-                To: alice@example.org\n\
+                b"From: Charlie <charlie@example.com>\n\
+                To: alice@example.com\n\
                Subject: Chat: hello\n\
                Chat-Version: 1.0\n\
-                Message-ID: <2223@example.org>\n\
+                Message-ID: <2223@example.com>\n\
                Date: Sun, 22 Mar 2020 22:37:56 +0000\n\
                \n\
                hello\n"
@@ -1343,10 +1380,11 @@ mod tests {
        );

        // 3. Send the first message to a new contact
-        let t = configured_offline_context().await;
-        assert_eq!(first_subject_str(t).await, "Message from alice@example.org");
+        let t = TestContext::new_alice().await;

-        let t = configured_offline_context().await;
+        assert_eq!(first_subject_str(t).await, "Message from alice@example.com");
+
+        let t = TestContext::new_alice().await;
        t.ctx
            .set_config(Config::Displayname, Some("Alice"))
            .await
@@ -1355,11 +1393,11 @@ mod tests {

        // 4. Receive messages with unicode characters and make sure that we do not panic (we do not care about the result)
        msg_to_subject_str(
-            "From: Charlie <charlie@example.org>\n\
-            To: alice@example.org\n\
+            "From: Charlie <charlie@example.com>\n\
+            To: alice@example.com\n\
            Subject: äääää\n\
            Chat-Version: 1.0\n\
-            Message-ID: <2893@example.org>\n\
+            Message-ID: <2893@example.com>\n\
            Date: Sun, 22 Mar 2020 22:37:56 +0000\n\
            \n\
            hello\n"
@@ -1368,11 +1406,11 @@ mod tests {
        .await;

        msg_to_subject_str(
-            "From: Charlie <charlie@example.org>\n\
-            To: alice@example.org\n\
+            "From: Charlie <charlie@example.com>\n\
+            To: alice@example.com\n\
            Subject: aäääää\n\
            Chat-Version: 1.0\n\
-            Message-ID: <2893@example.org>\n\
+            Message-ID: <2893@example.com>\n\
            Date: Sun, 22 Mar 2020 22:37:56 +0000\n\
            \n\
            hello\n"
@@ -1383,7 +1421,7 @@ mod tests {

    async fn first_subject_str(t: TestContext) -> String {
        let contact_id =
-            Contact::add_or_lookup(&t.ctx, "Dave", "dave@example.org", Origin::ManuallyCreated)
+            Contact::add_or_lookup(&t.ctx, "Dave", "dave@example.com", Origin::ManuallyCreated)
                .await
                .unwrap()
                .0;
@@ -1407,7 +1445,7 @@ mod tests {
    }

    async fn msg_to_subject_str(imf_raw: &[u8]) -> String {
-        let t = configured_offline_context().await;
+        let t = TestContext::new_alice().await;
        let new_msg = incoming_msg_to_reply_msg(imf_raw, &t.ctx).await;
        let mf = MimeFactory::from_msg(&t.ctx, &new_msg, false)
            .await
@@ -1445,15 +1483,15 @@ mod tests {
    #[async_std::test]
    // This test could still be extended
    async fn test_render_reply() {
-        let t = configured_offline_context().await;
+        let t = TestContext::new_alice().await;
        let context = &t.ctx;

        let msg = incoming_msg_to_reply_msg(
-            b"From: Charlie <charlie@example.org>\n\
-                To: alice@example.org\n\
+            b"From: Charlie <charlie@example.com>\n\
+                To: alice@example.com\n\
                Subject: Chat: hello\n\
                Chat-Version: 1.0\n\
-                Message-ID: <2223@example.org>\n\
+                Message-ID: <2223@example.com>\n\
                Date: Sun, 22 Mar 2020 22:37:56 +0000\n\
                \n\
                hello\n",
@@ -1464,7 +1502,7 @@ mod tests {
        let mimefactory = MimeFactory::from_msg(&t.ctx, &msg, false).await.unwrap();

        let recipients = mimefactory.recipients();
-        assert_eq!(recipients, vec!["charlie@example.org"]);
+        assert_eq!(recipients, vec!["charlie@example.com"]);

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

--- a/src/mimeparser.rs
+++ b/src/mimeparser.rs
@@ -46,7 +46,14 @@ pub struct MimeMessage {
    pub from: Vec<SingleInfo>,
    pub chat_disposition_notification_to: Option<SingleInfo>,
    pub decrypting_failed: bool,
+
+    /// Set of valid signature fingerprints if a message is an
+    /// Autocrypt encrypted and signed message.
+    ///
+    /// If a message is not encrypted or the signature is not valid,
+    /// this set is empty.
    pub signatures: HashSet<Fingerprint>,
+
    pub gossipped_addr: HashSet<String>,
    pub is_forwarded: bool,
    pub is_system_message: SystemMessage,
@@ -76,6 +83,9 @@ pub enum SystemMessage {
    SecurejoinMessage = 7,
    LocationStreamingEnabled = 8,
    LocationOnly = 9,
+
+    /// Chat ephemeral message timer is changed.
+    EphemeralTimerChanged = 10,
 }

 impl Default for SystemMessage {
@@ -214,6 +224,8 @@ impl MimeMessage {
        } else if let Some(value) = self.get(HeaderDef::ChatContent) {
            if value == "location-streaming-enabled" {
                self.is_system_message = SystemMessage::LocationStreamingEnabled;
+            } else if value == "ephemeral-timer-changed" {
+                self.is_system_message = SystemMessage::EphemeralTimerChanged;
            }
        }
        Ok(())
@@ -234,6 +246,7 @@ impl MimeMessage {
    ///
    /// Delta Chat sends attachments, such as images, in two-part messages, with the first message
    /// containing an explanation. If such a message is detected, first part can be safely dropped.
+    #[allow(clippy::indexing_slicing)]
    fn squash_attachment_parts(&mut self) {
        if let [textpart, filepart] = &self.parts[..] {
            let need_drop = {
@@ -267,22 +280,21 @@ impl MimeMessage {
    fn parse_attachments(&mut self) {
        // Attachment messages should be squashed into a single part
        // before calling this function.
-        if self.parts.len() == 1 {
-            if self.parts[0].typ == Viewtype::Audio
-                && self.get(HeaderDef::ChatVoiceMessage).is_some()
-            {
-                let part_mut = &mut self.parts[0];
-                part_mut.typ = Viewtype::Voice;
+        if self.parts.len() != 1 {
+            return;
+        }
+
+        if let Some(mut part) = self.parts.pop() {
+            if part.typ == Viewtype::Audio && self.get(HeaderDef::ChatVoiceMessage).is_some() {
+                part.typ = Viewtype::Voice;
            }
-            if self.parts[0].typ == Viewtype::Image {
+            if part.typ == Viewtype::Image {
                if let Some(value) = self.get(HeaderDef::ChatContent) {
                    if value == "sticker" {
-                        let part_mut = &mut self.parts[0];
-                        part_mut.typ = Viewtype::Sticker;
+                        part.typ = Viewtype::Sticker;
                    }
                }
            }
-            let part = &self.parts[0];
            if part.typ == Viewtype::Audio
                || part.typ == Viewtype::Voice
                || part.typ == Viewtype::Video
@@ -290,11 +302,12 @@ impl MimeMessage {
                if let Some(field_0) = self.get(HeaderDef::ChatDuration) {
                    let duration_ms = field_0.parse().unwrap_or_default();
                    if duration_ms > 0 && duration_ms < 24 * 60 * 60 * 1000 {
-                        let part_mut = &mut self.parts[0];
-                        part_mut.param.set_int(Param::Duration, duration_ms);
+                        part.param.set_int(Param::Duration, duration_ms);
                    }
                }
            }
+
+            self.parts.push(part);
        }
    }

@@ -316,12 +329,11 @@ impl MimeMessage {
                }
            }
            if prepend_subject {
-                let subj = if let Some(n) = subject.find('[') {
-                    &subject[0..n]
-                } else {
-                    subject
-                }
-                .trim();
+                let subj = subject
+                    .find('[')
+                    .and_then(|n| subject.get(..n))
+                    .unwrap_or(subject)
+                    .trim();

                if !subj.is_empty() {
                    for part in self.parts.iter_mut() {
@@ -379,8 +391,7 @@ impl MimeMessage {
            Some(AvatarAction::Delete)
        } else {
            let mut i = 0;
-            while i != self.parts.len() {
-                let part = &mut self.parts[i];
+            while let Some(part) = self.parts.get_mut(i) {
                if let Some(part_filename) = &part.org_filename {
                    if part_filename == &header_value {
                        if let Some(blob) = part.param.get(Param::File) {
@@ -397,6 +408,11 @@ impl MimeMessage {
        }
    }

+    /// Returns true if the message was encrypted as defined in
+    /// Autocrypt standard.
+    ///
+    /// This means the message was both encrypted and signed with a
+    /// valid signature.
    pub fn was_encrypted(&self) -> bool {
        !self.signatures.is_empty()
    }
@@ -765,16 +781,11 @@ impl MimeMessage {
    }

    pub fn repl_msg_by_error(&mut self, error_msg: impl AsRef<str>) {
-        if self.parts.is_empty() {
-            return;
+        if let Some(part) = self.parts.first_mut() {
+            part.typ = Viewtype::Text;
+            part.msg = format!("[{}]", error_msg.as_ref());
+            self.parts.truncate(1);
        }
-
-        let part = &mut self.parts[0];
-        part.typ = Viewtype::Text;
-        part.msg = format!("[{}]", error_msg.as_ref());
-        self.parts.truncate(1);
-
-        assert_eq!(self.parts.len(), 1);
    }

    pub fn get_rfc724_mid(&self) -> Option<String> {
@@ -825,7 +836,11 @@ impl MimeMessage {
        report: &mailparse::ParsedMail<'_>,
    ) -> Result<Option<Report>> {
        // parse as mailheaders
-        let report_body = report.subparts[1].get_body_raw()?;
+        let report_body = if let Some(subpart) = report.subparts.get(1) {
+            subpart.get_body_raw()?
+        } else {
+            bail!("Report does not have second MIME part");
+        };
        let (report_fields, _) = mailparse::parse_headers(&report_body)?;

        // must be present
@@ -903,6 +918,7 @@ impl MimeMessage {
    /// Some providers like GMX and Yahoo do not send standard NDNs (Non Delivery notifications).
    /// If you improve heuristics here you might also have to change prefetch_should_download() in imap/mod.rs.
    /// Also you should add a test in dc_receive_imf.rs (there already are lots of test_parse_ndn_* tests).
+    #[allow(clippy::indexing_slicing)]
    async fn heuristically_parse_ndn(&mut self, context: &Context) -> Option<()> {
        let maybe_ndn = if let Some(from) = self.get(HeaderDef::From_) {
            let from = from.to_ascii_lowercase();
@@ -961,11 +977,10 @@ impl MimeMessage {
        if let Some(failure_report) = &self.failure_report {
            let error = parts.iter().find(|p| p.typ == Viewtype::Text).map(|p| {
                let msg = &p.msg;
-                match msg.find("\n--- ") {
-                    Some(footer_start) => &msg[..footer_start],
-                    None => msg,
-                }
-                .trim()
+                msg.find("\n--- ")
+                    .and_then(|footer_start| msg.get(..footer_start))
+                    .unwrap_or(msg)
+                    .trim()
            });
            message::handle_ndn(context, failure_report, error).await
        }
@@ -1031,6 +1046,7 @@ pub(crate) struct FailureReport {
    pub failed_recipient: Option<String>,
 }

+#[allow(clippy::indexing_slicing)]
 pub(crate) fn parse_message_ids(ids: &str) -> Result<Vec<String>> {
    // take care with mailparse::msgidparse() that is pretty untolerant eg. wrt missing `<` or `>`
    let mut msgids = Vec::new();
@@ -1237,7 +1253,7 @@ mod tests {

    #[async_std::test]
    async fn test_dc_mimeparser_crash() {
-        let context = dummy_context().await;
+        let context = TestContext::new().await;
        let raw = include_bytes!("../test-data/message/issue_523.txt");
        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..])
            .await
@@ -1249,7 +1265,7 @@ mod tests {

    #[async_std::test]
    async fn test_get_rfc724_mid_exists() {
-        let context = dummy_context().await;
+        let context = TestContext::new().await;
        let raw = include_bytes!("../test-data/message/mail_with_message_id.txt");
        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..])
            .await
@@ -1263,7 +1279,7 @@ mod tests {

    #[async_std::test]
    async fn test_get_rfc724_mid_not_exists() {
-        let context = dummy_context().await;
+        let context = TestContext::new().await;
        let raw = include_bytes!("../test-data/message/issue_523.txt");
        let mimeparser = MimeMessage::from_bytes(&context.ctx, &raw[..])
            .await
@@ -1321,7 +1337,7 @@ mod tests {

    #[async_std::test]
    async fn test_parse_first_addr() {
-        let context = dummy_context().await;
+        let context = TestContext::new().await;
        let raw = b"From: hello@one.org, world@two.org\n\
                    Chat-Disposition-Notification-To: wrong\n\
                    Content-Type: text/plain\n\
@@ -1342,7 +1358,7 @@ mod tests {

    #[async_std::test]
    async fn test_mimeparser_with_context() {
-        let context = dummy_context().await;
+        let context = TestContext::new().await;
        let raw = b"From: hello\n\
                    Content-Type: multipart/mixed; boundary=\"==break==\";\n\
                    Subject: outer-subject\n\
@@ -1392,7 +1408,7 @@ mod tests {

    #[async_std::test]
    async fn test_mimeparser_with_avatars() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;

        let raw = include_bytes!("../test-data/message/mail_attach_txt.eml");
        let mimeparser = MimeMessage::from_bytes(&t.ctx, &raw[..]).await.unwrap();
@@ -1435,7 +1451,7 @@ mod tests {

    #[async_std::test]
    async fn test_mimeparser_message_kml() {
-        let context = dummy_context().await;
+        let context = TestContext::new().await;
        let raw = b"Chat-Version: 1.0\n\
 From: foo <foo@example.org>\n\
 To: bar <bar@example.org>\n\
@@ -1480,7 +1496,7 @@ Content-Disposition: attachment; filename=\"message.kml\"\n\

    #[async_std::test]
    async fn test_parse_mdn() {
-        let context = dummy_context().await;
+        let context = TestContext::new().await;
        let raw = b"Subject: =?utf-8?q?Chat=3A_Message_opened?=\n\
 Date: Mon, 10 Jan 2020 00:00:00 +0000\n\
 Chat-Version: 1.0\n\
@@ -1530,7 +1546,7 @@ Disposition: manual-action/MDN-sent-automatically; displayed\n\
    /// multipart MIME messages.
    #[async_std::test]
    async fn test_parse_multiple_mdns() {
-        let context = dummy_context().await;
+        let context = TestContext::new().await;
        let raw = b"Subject: =?utf-8?q?Chat=3A_Message_opened?=\n\
 Date: Mon, 10 Jan 2020 00:00:00 +0000\n\
 Chat-Version: 1.0\n\
@@ -1606,7 +1622,7 @@ Disposition: manual-action/MDN-sent-automatically; displayed\n\

    #[async_std::test]
    async fn test_parse_mdn_with_additional_message_ids() {
-        let context = dummy_context().await;
+        let context = TestContext::new().await;
        let raw = b"Subject: =?utf-8?q?Chat=3A_Message_opened?=\n\
 Date: Mon, 10 Jan 2020 00:00:00 +0000\n\
 Chat-Version: 1.0\n\
@@ -1661,7 +1677,7 @@ Additional-Message-IDs: <foo@example.com> <foo@example.net>\n\

    #[async_std::test]
    async fn test_parse_inline_attachment() {
-        let context = dummy_context().await;
+        let context = TestContext::new().await;
        let raw = br#"Date: Thu, 13 Feb 2020 22:41:20 +0000 (UTC)
 From: sender@example.com
 To: receiver@example.com
@@ -1701,7 +1717,7 @@ MDYyMDYxNTE1RTlDOEE4Cj4+CnN0YXJ0eHJlZgo4Mjc4CiUlRU9GCg==

    #[async_std::test]
    async fn parse_inline_image() {
-        let context = dummy_context().await;
+        let context = TestContext::new().await;
        let raw = br#"Message-ID: <foobar@example.org>
 From: foo <foo@example.org>
 Subject: example
@@ -1747,7 +1763,7 @@ CWt6wx7fiLp0qS9RrX75g6Gqw7nfCs6EcBERcIPt7DTe8VStJwf3LWqVwxl4gQl46yhfoqwEO+I=

    #[async_std::test]
    async fn parse_thunderbird_html_embedded_image() {
-        let context = dummy_context().await;
+        let context = TestContext::new().await;
        let raw = br#"To: Alice <alice@example.org>
 From: Bob <bob@example.org>
 Subject: Test subject
@@ -1820,7 +1836,7 @@ CWt6wx7fiLp0qS9RrX75g6Gqw7nfCs6EcBERcIPt7DTe8VStJwf3LWqVwxl4gQl46yhfoqwEO+I=
    // Outlook specifies filename in the "name" attribute of Content-Type
    #[async_std::test]
    async fn parse_outlook_html_embedded_image() {
-        let context = dummy_context().await;
+        let context = TestContext::new().await;
        let raw = br##"From: Anonymous <anonymous@example.org>
 To: Anonymous <anonymous@example.org>
 Subject: Delta Chat is great stuff!
--- a/src/oauth2.rs
+++ b/src/oauth2.rs
@@ -436,7 +436,7 @@ mod tests {

    #[async_std::test]
    async fn test_dc_get_oauth2_addr() {
-        let ctx = dummy_context().await;
+        let ctx = TestContext::new().await;
        let addr = "dignifiedquire@gmail.com";
        let code = "fail";
        let res = dc_get_oauth2_addr(&ctx.ctx, addr, code).await;
@@ -446,7 +446,7 @@ mod tests {

    #[async_std::test]
    async fn test_dc_get_oauth2_url() {
-        let ctx = dummy_context().await;
+        let ctx = TestContext::new().await;
        let addr = "dignifiedquire@gmail.com";
        let redirect_uri = "chat.delta:/com.b44t.messenger";
        let res = dc_get_oauth2_url(&ctx.ctx, addr, redirect_uri).await;
@@ -456,7 +456,7 @@ mod tests {

    #[async_std::test]
    async fn test_dc_get_oauth2_token() {
-        let ctx = dummy_context().await;
+        let ctx = TestContext::new().await;
        let addr = "dignifiedquire@gmail.com";
        let code = "fail";
        let res = dc_get_oauth2_access_token(&ctx.ctx, addr, code, false).await;
--- a/src/param.rs
+++ b/src/param.rs
@@ -171,7 +171,7 @@ impl str::FromStr for Params {
            let key = key.unwrap_or_default().trim();
            let value = value.unwrap_or_default().trim();

-            if let Some(key) = Param::from_u8(key.as_bytes()[0]) {
+            if let Some(key) = key.as_bytes().first().and_then(|key| Param::from_u8(*key)) {
                inner.insert(key, value.to_string());
            } else {
                bail!("Unknown key: {}", key);
@@ -414,7 +414,7 @@ mod tests {

    #[async_std::test]
    async fn test_params_file_fs_path() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        if let ParamsFile::FsPath(p) = ParamsFile::from_param(&t.ctx, "/foo/bar/baz").unwrap() {
            assert_eq!(p, Path::new("/foo/bar/baz"));
        } else {
@@ -424,7 +424,7 @@ mod tests {

    #[async_std::test]
    async fn test_params_file_blob() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        if let ParamsFile::Blob(b) = ParamsFile::from_param(&t.ctx, "$BLOBDIR/foo").unwrap() {
            assert_eq!(b.as_name(), "$BLOBDIR/foo");
        } else {
@@ -435,7 +435,7 @@ mod tests {
    // Tests for Params::get_file(), Params::get_path() and Params::get_blob().
    #[async_std::test]
    async fn test_params_get_fileparam() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let fname = t.dir.path().join("foo");
        let mut p = Params::new();
        p.set(Param::File, fname.to_str().unwrap());
--- a/src/peerstate.rs
+++ b/src/peerstate.rs
@@ -1,6 +1,5 @@
 //! # [Autocrypt Peer State](https://autocrypt.org/level1.html#peer-state-management) module
 use std::collections::HashSet;
-use std::convert::TryFrom;
 use std::fmt;

 use num_traits::FromPrimitive;
@@ -324,11 +323,9 @@ impl<'a> Peerstate<'a> {

    pub fn render_gossip_header(&self, min_verified: PeerstateVerifiedStatus) -> Option<String> {
        if let Some(key) = self.peek_key(min_verified) {
-            // TODO: avoid cloning
-            let public_key = SignedPublicKey::try_from(key.clone()).ok()?;
            let header = Aheader::new(
                self.addr.clone(),
-                public_key,
+                key.clone(), // TODO: avoid cloning
                // Autocrypt 1.1.0 specification says that
                // `prefer-encrypt` attribute SHOULD NOT be included,
                // but we include it anyway to propagate encryption
@@ -473,7 +470,7 @@ mod tests {

    #[async_std::test]
    async fn test_peerstate_save_to_db() {
-        let ctx = crate::test_utils::dummy_context().await;
+        let ctx = crate::test_utils::TestContext::new().await;
        let addr = "hello@mail.com";

        let pub_key = alice_keypair().public;
@@ -516,7 +513,7 @@ mod tests {

    #[async_std::test]
    async fn test_peerstate_double_create() {
-        let ctx = crate::test_utils::dummy_context().await;
+        let ctx = crate::test_utils::TestContext::new().await;
        let addr = "hello@mail.com";
        let pub_key = alice_keypair().public;

@@ -549,7 +546,7 @@ mod tests {

    #[async_std::test]
    async fn test_peerstate_with_empty_gossip_key_save_to_db() {
-        let ctx = crate::test_utils::dummy_context().await;
+        let ctx = crate::test_utils::TestContext::new().await;
        let addr = "hello@mail.com";

        let pub_key = alice_keypair().public;
--- a/src/pgp.rs
+++ b/src/pgp.rs
@@ -365,11 +365,13 @@ pub async fn symm_decrypt<T: std::io::Read + std::io::Seek>(
        let decryptor = enc_msg.decrypt_with_password(|| passphrase)?;

        let msgs = decryptor.collect::<pgp::errors::Result<Vec<_>>>()?;
-        ensure!(!msgs.is_empty(), "No valid messages found");
-
-        match msgs[0].get_content()? {
-            Some(content) => Ok(content),
-            None => bail!("Decrypted message is empty"),
+        if let Some(msg) = msgs.first() {
+            match msg.get_content()? {
+                Some(content) => Ok(content),
+                None => bail!("Decrypted message is empty"),
+            }
+        } else {
+            bail!("No valid messages found")
        }
    })
    .await
--- a/src/provider/data.rs
+++ b/src/provider/data.rs
@@ -135,6 +135,24 @@ lazy_static::lazy_static! {
        oauth2_authorizer: None,
    };

+    // dubby.org.md: dubby.org
+    static ref P_DUBBY_ORG: Provider = Provider {
+        status: Status::OK,
+        before_login_hint: "",
+        after_login_hint: "",
+        overview_page: "https://providers.delta.chat/dubby-org",
+        server: vec![
+        ],
+        config_defaults: Some(vec![
+            ConfigDefault { key: Config::BccSelf, value: "1" },
+            ConfigDefault { key: Config::SentboxWatch, value: "0" },
+            ConfigDefault { key: Config::MvboxWatch, value: "0" },
+            ConfigDefault { key: Config::MvboxMove, value: "0" },
+        ]),
+        strict_tls: true,
+        oauth2_authorizer: None,
+    };
+
    // example.com.md: example.com, example.org
    static ref P_EXAMPLE_COM: Provider = Provider {
        status: Status::BROKEN,
@@ -171,7 +189,12 @@ lazy_static::lazy_static! {
        overview_page: "https://providers.delta.chat/five-chat",
        server: vec![
        ],
-        config_defaults: None,
+        config_defaults: Some(vec![
+            ConfigDefault { key: Config::BccSelf, value: "1" },
+            ConfigDefault { key: Config::SentboxWatch, value: "0" },
+            ConfigDefault { key: Config::MvboxWatch, value: "0" },
+            ConfigDefault { key: Config::MvboxMove, value: "0" },
+        ]),
        strict_tls: true,
        oauth2_authorizer: None,
    };
@@ -222,6 +245,19 @@ lazy_static::lazy_static! {
        oauth2_authorizer: None,
    };

+    // hey.com.md: hey.com
+    static ref P_HEY_COM: Provider = Provider {
+        status: Status::BROKEN,
+        before_login_hint: "hey.com does not offer the standard IMAP e-mail protocol, so you cannot log in with Delta Chat to hey.com.",
+        after_login_hint: "",
+        overview_page: "https://providers.delta.chat/hey-com",
+        server: vec![
+        ],
+        config_defaults: None,
+        strict_tls: false,
+        oauth2_authorizer: None,
+    };
+
    // i.ua.md: i.ua
    static ref P_I_UA: Provider = Provider {
        status: Status::OK,
@@ -431,7 +467,12 @@ lazy_static::lazy_static! {
            Server { protocol: IMAP, socket: STARTTLS, hostname: "testrun.org", port: 143, username_pattern: EMAIL },
            Server { protocol: SMTP, socket: STARTTLS, hostname: "testrun.org", port: 587, username_pattern: EMAIL },
        ],
-        config_defaults: None,
+        config_defaults: Some(vec![
+            ConfigDefault { key: Config::BccSelf, value: "1" },
+            ConfigDefault { key: Config::SentboxWatch, value: "0" },
+            ConfigDefault { key: Config::MvboxWatch, value: "0" },
+            ConfigDefault { key: Config::MvboxMove, value: "0" },
+        ]),
        strict_tls: true,
        oauth2_authorizer: None,
    };
@@ -547,6 +588,7 @@ lazy_static::lazy_static! {
        ("comcast.net", &*P_COMCAST),
        ("dismail.de", &*P_DISMAIL_DE),
        ("disroot.org", &*P_DISROOT),
+        ("dubby.org", &*P_DUBBY_ORG),
        ("example.com", &*P_EXAMPLE_COM),
        ("example.org", &*P_EXAMPLE_COM),
        ("fastmail.com", &*P_FASTMAIL),
@@ -563,6 +605,7 @@ lazy_static::lazy_static! {
        ("gmx.info", &*P_GMX_NET),
        ("gmx.biz", &*P_GMX_NET),
        ("gmx.com", &*P_GMX_NET),
+        ("hey.com", &*P_HEY_COM),
        ("i.ua", &*P_I_UA),
        ("icloud.com", &*P_ICLOUD),
        ("me.com", &*P_ICLOUD),
--- a/src/qr.rs
+++ b/src/qr.rs
@@ -68,6 +68,7 @@ pub async fn check_qr(context: &Context, qr: impl AsRef<str>) -> Lot {

 /// scheme: `OPENPGP4FPR:FINGERPRINT#a=ADDR&n=NAME&i=INVITENUMBER&s=AUTH`
 ///     or: `OPENPGP4FPR:FINGERPRINT#a=ADDR&g=GROUPNAME&x=GROUPID&i=INVITENUMBER&s=AUTH`
+#[allow(clippy::indexing_slicing)]
 async fn decode_openpgp(context: &Context, qr: &str) -> Lot {
    let payload = &qr[OPENPGP4FPR_SCHEME.len()..];

@@ -187,6 +188,7 @@ async fn decode_openpgp(context: &Context, qr: &str) -> Lot {
 }

 /// scheme: `DCACCOUNT:https://example.org/new_email?t=1w_7wDjgjelxeX884x96v3`
+#[allow(clippy::indexing_slicing)]
 fn decode_account(_context: &Context, qr: &str) -> Lot {
    let payload = &qr[DCACCOUNT_SCHEME.len()..];

@@ -217,6 +219,7 @@ struct CreateAccountResponse {
 /// take a qr of the type DC_QR_ACCOUNT, parse it's parameters,
 /// download additional information from the contained url and set the parameters.
 /// on success, a configure::configure() should be able to log in to the account
+#[allow(clippy::indexing_slicing)]
 pub async fn set_config_from_qr(context: &Context, qr: &str) -> Result<(), Error> {
    let url_str = &qr[DCACCOUNT_SCHEME.len()..];

@@ -240,6 +243,7 @@ pub async fn set_config_from_qr(context: &Context, qr: &str) -> Result<(), Error
 /// Extract address for the mailto scheme.
 ///
 /// Scheme: `mailto:addr...?subject=...&body=..`
+#[allow(clippy::indexing_slicing)]
 async fn decode_mailto(context: &Context, qr: &str) -> Lot {
    let payload = &qr[MAILTO_SCHEME.len()..];

@@ -261,6 +265,7 @@ async fn decode_mailto(context: &Context, qr: &str) -> Lot {
 /// Extract address for the smtp scheme.
 ///
 /// Scheme: `SMTP:addr...:subject...:body...`
+#[allow(clippy::indexing_slicing)]
 async fn decode_smtp(context: &Context, qr: &str) -> Lot {
    let payload = &qr[SMTP_SCHEME.len()..];

@@ -283,6 +288,7 @@ async fn decode_smtp(context: &Context, qr: &str) -> Lot {
 /// Scheme: `MATMSG:TO:addr...;SUB:subject...;BODY:body...;`
 ///
 /// There may or may not be linebreaks after the fields.
+#[allow(clippy::indexing_slicing)]
 async fn decode_matmsg(context: &Context, qr: &str) -> Lot {
    // Does not work when the text `TO:` is used in subject/body _and_ TO: is not the first field.
    // we ignore this case.
@@ -316,14 +322,15 @@ lazy_static! {
 /// Extract address for the matmsg scheme.
 ///
 /// Scheme: `VCARD:BEGIN\nN:last name;first name;...;\nEMAIL;<type>:addr...;
+#[allow(clippy::indexing_slicing)]
 async fn decode_vcard(context: &Context, qr: &str) -> Lot {
    let name = VCARD_NAME_RE
        .captures(qr)
-        .map(|caps| {
-            let last_name = &caps[1];
-            let first_name = &caps[2];
+        .and_then(|caps| {
+            let last_name = caps.get(1)?.as_str().trim();
+            let first_name = caps.get(2)?.as_str().trim();

-            format!("{} {}", first_name.trim(), last_name.trim())
+            Some(format!("{} {}", first_name, last_name))
        })
        .unwrap_or_default();

@@ -383,11 +390,11 @@ fn normalize_address(addr: &str) -> Result<String, Error> {
 mod tests {
    use super::*;

-    use crate::test_utils::dummy_context;
+    use crate::test_utils::TestContext;

    #[async_std::test]
    async fn test_decode_http() {
-        let ctx = dummy_context().await;
+        let ctx = TestContext::new().await;

        let res = check_qr(&ctx.ctx, "http://www.hello.com").await;

@@ -399,7 +406,7 @@ mod tests {

    #[async_std::test]
    async fn test_decode_https() {
-        let ctx = dummy_context().await;
+        let ctx = TestContext::new().await;

        let res = check_qr(&ctx.ctx, "https://www.hello.com").await;

@@ -411,7 +418,7 @@ mod tests {

    #[async_std::test]
    async fn test_decode_text() {
-        let ctx = dummy_context().await;
+        let ctx = TestContext::new().await;

        let res = check_qr(&ctx.ctx, "I am so cool").await;

@@ -423,7 +430,7 @@ mod tests {

    #[async_std::test]
    async fn test_decode_vcard() {
-        let ctx = dummy_context().await;
+        let ctx = TestContext::new().await;

        let res = check_qr(
            &ctx.ctx,
@@ -441,7 +448,7 @@ mod tests {

    #[async_std::test]
    async fn test_decode_matmsg() {
-        let ctx = dummy_context().await;
+        let ctx = TestContext::new().await;

        let res = check_qr(
            &ctx.ctx,
@@ -459,7 +466,7 @@ mod tests {

    #[async_std::test]
    async fn test_decode_mailto() {
-        let ctx = dummy_context().await;
+        let ctx = TestContext::new().await;

        let res = check_qr(
            &ctx.ctx,
@@ -485,7 +492,7 @@ mod tests {

    #[async_std::test]
    async fn test_decode_smtp() {
-        let ctx = dummy_context().await;
+        let ctx = TestContext::new().await;

        let res = check_qr(&ctx.ctx, "SMTP:stress@test.local:subjecthello:bodyworld").await;

@@ -499,7 +506,7 @@ mod tests {

    #[async_std::test]
    async fn test_decode_openpgp_group() {
-        let ctx = dummy_context().await;
+        let ctx = TestContext::new().await;

        let res = check_qr(
            &ctx.ctx,
@@ -528,7 +535,7 @@ mod tests {

    #[async_std::test]
    async fn test_decode_openpgp_secure_join() {
-        let ctx = dummy_context().await;
+        let ctx = TestContext::new().await;

        let res = check_qr(
            &ctx.ctx,
@@ -556,7 +563,7 @@ mod tests {

    #[async_std::test]
    async fn test_decode_openpgp_without_addr() {
-        let ctx = dummy_context().await;
+        let ctx = TestContext::new().await;

        let res = check_qr(
            &ctx.ctx,
@@ -591,7 +598,7 @@ mod tests {

    #[async_std::test]
    async fn test_decode_account() {
-        let ctx = dummy_context().await;
+        let ctx = TestContext::new().await;

        let res = check_qr(
            &ctx.ctx,
@@ -613,7 +620,7 @@ mod tests {

    #[async_std::test]
    async fn test_decode_account_bad_scheme() {
-        let ctx = dummy_context().await;
+        let ctx = TestContext::new().await;
        let res = check_qr(
            &ctx.ctx,
            "DCACCOUNT:http://example.org/new_email?t=1w_7wDjgjelxeX884x96v3",
--- a/src/scheduler.rs
+++ b/src/scheduler.rs
@@ -1,5 +1,3 @@
-#![warn(clippy::indexing_slicing)]
-
 use async_std::prelude::*;
 use async_std::sync::{channel, Receiver, Sender};
 use async_std::task;
@@ -38,14 +36,6 @@ impl Context {
        self.scheduler.read().await.interrupt_inbox(info).await;
    }

-    pub(crate) async fn interrupt_sentbox(&self, info: InterruptInfo) {
-        self.scheduler.read().await.interrupt_sentbox(info).await;
-    }
-
-    pub(crate) async fn interrupt_mvbox(&self, info: InterruptInfo) {
-        self.scheduler.read().await.interrupt_mvbox(info).await;
-    }
-
    pub(crate) async fn interrupt_smtp(&self, info: InterruptInfo) {
        self.scheduler.read().await.interrupt_smtp(info).await;
    }
@@ -84,7 +74,18 @@ async fn inbox_loop(ctx: Context, started: Sender<()>, inbox_handlers: ImapConne
                }
                None => {
                    jobs_loaded = 0;
-                    info = fetch_idle(&ctx, &mut connection, Config::ConfiguredInboxFolder).await;
+
+                    // Expunge folder if needed, e.g. if some jobs have
+                    // deleted messages on the server.
+                    if let Err(err) = connection.maybe_close_folder(&ctx).await {
+                        warn!(ctx, "failed to close folder: {:?}", err);
+                    }
+
+                    info = if ctx.get_config_bool(Config::InboxWatch).await {
+                        fetch_idle(&ctx, &mut connection, Config::ConfiguredInboxFolder).await
+                    } else {
+                        connection.fake_idle(&ctx, None).await
+                    };
                }
            }
        }
@@ -126,7 +127,7 @@ async fn fetch_idle(ctx: &Context, connection: &mut Imap, folder: Config) -> Int
        Some(watch_folder) => {
            // connect and fake idle if unable to connect
            if let Err(err) = connection.connect_configured(&ctx).await {
-                error!(ctx, "imap connection failed: {}", err);
+                warn!(ctx, "imap connection failed: {}", err);
                return connection.fake_idle(&ctx, None).await;
            }

@@ -245,29 +246,21 @@ impl Scheduler {
        let (smtp, smtp_handlers) = SmtpConnectionState::new();
        let (inbox, inbox_handlers) = ImapConnectionState::new();

-        *self = Scheduler::Running {
-            inbox,
-            mvbox,
-            sentbox,
-            smtp,
-            inbox_handle: None,
-            mvbox_handle: None,
-            sentbox_handle: None,
-            smtp_handle: None,
-        };
-
        let (inbox_start_send, inbox_start_recv) = channel(1);
-        if let Scheduler::Running { inbox_handle, .. } = self {
-            let ctx1 = ctx.clone();
-            *inbox_handle = Some(task::spawn(async move {
-                inbox_loop(ctx1, inbox_start_send, inbox_handlers).await
-            }));
-        }
-
        let (mvbox_start_send, mvbox_start_recv) = channel(1);
-        if let Scheduler::Running { mvbox_handle, .. } = self {
+        let mut mvbox_handle = None;
+        let (sentbox_start_send, sentbox_start_recv) = channel(1);
+        let mut sentbox_handle = None;
+        let (smtp_start_send, smtp_start_recv) = channel(1);
+
+        let ctx1 = ctx.clone();
+        let inbox_handle = Some(task::spawn(async move {
+            inbox_loop(ctx1, inbox_start_send, inbox_handlers).await
+        }));
+
+        if ctx.get_config_bool(Config::MvboxWatch).await {
            let ctx1 = ctx.clone();
-            *mvbox_handle = Some(task::spawn(async move {
+            mvbox_handle = Some(task::spawn(async move {
                simple_imap_loop(
                    ctx1,
                    mvbox_start_send,
@@ -276,12 +269,13 @@ impl Scheduler {
                )
                .await
            }));
+        } else {
+            mvbox_start_send.send(()).await;
        }

-        let (sentbox_start_send, sentbox_start_recv) = channel(1);
-        if let Scheduler::Running { sentbox_handle, .. } = self {
+        if ctx.get_config_bool(Config::SentboxWatch).await {
            let ctx1 = ctx.clone();
-            *sentbox_handle = Some(task::spawn(async move {
+            sentbox_handle = Some(task::spawn(async move {
                simple_imap_loop(
                    ctx1,
                    sentbox_start_send,
@@ -290,15 +284,25 @@ impl Scheduler {
                )
                .await
            }));
+        } else {
+            sentbox_start_send.send(()).await;
        }

-        let (smtp_start_send, smtp_start_recv) = channel(1);
-        if let Scheduler::Running { smtp_handle, .. } = self {
-            let ctx1 = ctx.clone();
-            *smtp_handle = Some(task::spawn(async move {
-                smtp_loop(ctx1, smtp_start_send, smtp_handlers).await
-            }));
-        }
+        let ctx1 = ctx.clone();
+        let smtp_handle = Some(task::spawn(async move {
+            smtp_loop(ctx1, smtp_start_send, smtp_handlers).await
+        }));
+
+        *self = Scheduler::Running {
+            inbox,
+            mvbox,
+            sentbox,
+            smtp,
+            inbox_handle,
+            mvbox_handle,
+            sentbox_handle,
+            smtp_handle,
+        };

        // wait for all loops to be started
        if let Err(err) = inbox_start_recv
@@ -388,10 +392,18 @@ impl Scheduler {
                smtp_handle,
                ..
            } => {
-                inbox_handle.take().expect("inbox not started").await;
-                mvbox_handle.take().expect("mvbox not started").await;
-                sentbox_handle.take().expect("sentbox not started").await;
-                smtp_handle.take().expect("smtp not started").await;
+                if let Some(handle) = inbox_handle.take() {
+                    handle.await;
+                }
+                if let Some(handle) = mvbox_handle.take() {
+                    handle.await;
+                }
+                if let Some(handle) = sentbox_handle.take() {
+                    handle.await;
+                }
+                if let Some(handle) = smtp_handle.take() {
+                    handle.await;
+                }

                *self = Scheduler::Stopped;
            }
--- a/src/securejoin.rs
+++ b/src/securejoin.rs
@@ -352,9 +352,8 @@ async fn send_handshake_msg(
 }

 async fn chat_id_2_contact_id(context: &Context, contact_chat_id: ChatId) -> u32 {
-    let contacts = chat::get_chat_contacts(context, contact_chat_id).await;
-    if contacts.len() == 1 {
-        contacts[0]
+    if let [contact_id] = chat::get_chat_contacts(context, contact_chat_id).await[..] {
+        contact_id
    } else {
        0
    }
@@ -365,10 +364,8 @@ async fn fingerprint_equals_sender(
    fingerprint: &Fingerprint,
    contact_chat_id: ChatId,
 ) -> bool {
-    let contacts = chat::get_chat_contacts(context, contact_chat_id).await;
-
-    if contacts.len() == 1 {
-        if let Ok(contact) = Contact::load_from_db(context, contacts[0]).await {
+    if let [contact_id] = chat::get_chat_contacts(context, contact_chat_id).await[..] {
+        if let Ok(contact) = Contact::load_from_db(context, contact_id).await {
            if let Some(peerstate) = Peerstate::from_addr(context, contact.get_addr()).await {
                if peerstate.public_key_fingerprint.is_some()
                    && fingerprint == peerstate.public_key_fingerprint.as_ref().unwrap()
@@ -426,6 +423,7 @@ pub(crate) enum HandshakeMessage {
 /// When handle_securejoin_handshake() is called,
 /// the message is not yet filed in the database;
 /// this is done by receive_imf() later on as needed.
+#[allow(clippy::indexing_slicing)]
 pub(crate) async fn handle_securejoin_handshake(
    context: &Context,
    mime_message: &MimeMessage,
@@ -1010,24 +1008,19 @@ fn encrypted_and_signed(
    if !mimeparser.was_encrypted() {
        warn!(context, "Message not encrypted.",);
        false
-    } else if mimeparser.signatures.is_empty() {
-        warn!(context, "Message not signed.",);
-        false
-    } else if expected_fingerprint.is_none() {
+    } else if let Some(expected_fingerprint) = expected_fingerprint {
+        if !mimeparser.signatures.contains(expected_fingerprint) {
+            warn!(
+                context,
+                "Message does not match expected fingerprint {}.", expected_fingerprint,
+            );
+            false
+        } else {
+            true
+        }
+    } else {
        warn!(context, "Fingerprint for comparison missing.");
        false
-    } else if !mimeparser
-        .signatures
-        .contains(expected_fingerprint.unwrap())
-    {
-        warn!(
-            context,
-            "Message does not match expected fingerprint {}.",
-            expected_fingerprint.unwrap(),
-        );
-        false
-    } else {
-        true
    }
 }

--- a/src/simplify.rs
+++ b/src/simplify.rs
@@ -6,6 +6,7 @@
 // this escapes a bit more than actually needed by delta (eg. also lines as "-- footer"),
 // but for non-delta-compatibility, that seems to be better.
 // (to be only compatible with delta, only "[\r\n|\n]-- {0,2}[\r\n|\n]" needs to be replaced)
+#[allow(clippy::indexing_slicing)]
 pub fn escape_message_footer_marks(text: &str) -> String {
    if text.starts_with("--") {
        "-\u{200B}-".to_string() + &text[2..].replace("\n--", "\n-\u{200B}-")
@@ -15,6 +16,7 @@ pub fn escape_message_footer_marks(text: &str) -> String {
 }

 /// Remove standard (RFC 3676, §4.3) footer if it is found.
+#[allow(clippy::indexing_slicing)]
 fn remove_message_footer<'a>(lines: &'a [&str]) -> &'a [&'a str] {
    let mut nearly_standard_footer = None;
    for (ix, &line) in lines.iter().enumerate() {
@@ -41,6 +43,7 @@ fn remove_message_footer<'a>(lines: &'a [&str]) -> &'a [&'a str] {

 /// Remove nonstandard footer and a boolean indicating whether such
 /// footer was removed.
+#[allow(clippy::indexing_slicing)]
 fn remove_nonstandard_footer<'a>(lines: &'a [&str]) -> (&'a [&'a str], bool) {
    for (ix, &line) in lines.iter().enumerate() {
        if line == "--"
@@ -107,6 +110,7 @@ fn skip_forward_header<'a>(lines: &'a [&str]) -> (&'a [&'a str], bool) {
    }
 }

+#[allow(clippy::indexing_slicing)]
 fn remove_bottom_quote<'a>(lines: &'a [&str]) -> (&'a [&'a str], bool) {
    let mut last_quoted_line = None;
    for (l, line) in lines.iter().enumerate().rev() {
@@ -132,6 +136,7 @@ fn remove_bottom_quote<'a>(lines: &'a [&str]) -> (&'a [&'a str], bool) {
    }
 }

+#[allow(clippy::indexing_slicing)]
 fn remove_top_quote<'a>(lines: &'a [&str]) -> (&'a [&'a str], bool) {
    let mut last_quoted_line = None;
    let mut has_quoted_headline = false;
--- a/src/smtp/mod.rs
+++ b/src/smtp/mod.rs
@@ -1,10 +1,8 @@
 //! # SMTP transport module

-#![forbid(clippy::indexing_slicing)]
-
 pub mod send;

-use std::time::{Duration, Instant};
+use std::time::{Duration, SystemTime};

 use async_smtp::smtp::client::net::*;
 use async_smtp::*;
@@ -57,7 +55,7 @@ pub(crate) struct Smtp {
    /// Timestamp of last successful send/receive network interaction
    /// (eg connect or send succeeded). On initialization and disconnect
    /// it is set to None.
-    last_success: Option<Instant>,
+    last_success: Option<SystemTime>,
 }

 impl Smtp {
@@ -78,7 +76,11 @@ impl Smtp {
    /// have been successfully used the last 60 seconds
    pub async fn has_maybe_stale_connection(&self) -> bool {
        if let Some(last_success) = self.last_success {
-            Instant::now().duration_since(last_success).as_secs() > 60
+            SystemTime::now()
+                .duration_since(last_success)
+                .unwrap_or_default()
+                .as_secs()
+                > 60
        } else {
            false
        }
@@ -181,7 +183,7 @@ impl Smtp {
                .stock_string_repl_str2(
                    StockMessage::ServerResponse,
                    format!("SMTP {}:{}", domain, port),
-                    format!("{}, ({:?})", err.to_string(), err),
+                    err.to_string(),
                )
                .await;

@@ -190,7 +192,7 @@ impl Smtp {
        }

        self.transport = Some(trans);
-        self.last_success = Some(Instant::now());
+        self.last_success = Some(SystemTime::now());

        context.emit_event(Event::SmtpConnected(format!(
            "SMTP-LOGIN as {} ok",
--- a/src/smtp/send.rs
+++ b/src/smtp/send.rs
@@ -53,7 +53,7 @@ impl Smtp {
                "Message len={} was smtp-sent to {}",
                message_len, recipients_display
            )));
-            self.last_success = Some(std::time::Instant::now());
+            self.last_success = Some(std::time::SystemTime::now());

            Ok(())
        } else {
--- a/src/sql.rs
+++ b/src/sql.rs
@@ -13,6 +13,7 @@ use crate::chat::{update_device_icon, update_saved_messages_icon};
 use crate::constants::{ShowEmails, DC_CHAT_ID_TRASH};
 use crate::context::Context;
 use crate::dc_tools::*;
+use crate::ephemeral::start_ephemeral_timers;
 use crate::param::*;
 use crate::peerstate::*;

@@ -568,16 +569,24 @@ pub async fn housekeeping(context: &Context) {
        }
    }

+    if let Err(err) = start_ephemeral_timers(context).await {
+        warn!(
+            context,
+            "Housekeeping: cannot start ephemeral timers: {}", err
+        );
+    }
+
    if let Err(err) = prune_tombstones(context).await {
        warn!(
            context,
-            "Houskeeping: Cannot prune message tombstones: {}", err
+            "Housekeeping: Cannot prune message tombstones: {}", err
        );
    }

    info!(context, "Housekeeping done.",);
 }

+#[allow(clippy::indexing_slicing)]
 fn is_file_in_use(files_in_use: &HashSet<String>, namespc_opt: Option<&str>, name: &str) -> bool {
    let name_to_check = if let Some(namespc) = namespc_opt {
        let name_len = name.len();
@@ -592,8 +601,9 @@ fn is_file_in_use(files_in_use: &HashSet<String>, namespc_opt: Option<&str>, nam
    files_in_use.contains(name_to_check)
 }

+#[allow(clippy::indexing_slicing)] // TODO: use str.strip_prefix once it is released in stable
 fn maybe_add_file(files_in_use: &mut HashSet<String>, file: impl AsRef<str>) {
-    if !file.as_ref().starts_with("$BLOBDIR") {
+    if !file.as_ref().starts_with("$BLOBDIR/") {
        return;
    }

@@ -1250,6 +1260,32 @@ async fn open(
            .await?;
            sql.set_raw_config_int(context, "dbversion", 64).await?;
        }
+        if dbversion < 65 {
+            info!(context, "[migration] v65");
+            sql.execute(
+                "ALTER TABLE chats ADD COLUMN ephemeral_timer INTEGER",
+                paramsv![],
+            )
+            .await?;
+            // Timer value in seconds. For incoming messages this
+            // timer starts when message is read, so we want to have
+            // the value stored here until the timer starts.
+            sql.execute(
+                "ALTER TABLE msgs ADD COLUMN ephemeral_timer INTEGER DEFAULT 0",
+                paramsv![],
+            )
+            .await?;
+            // Timestamp indicating when the message should be
+            // deleted. It is convenient to store it here because UI
+            // needs this value to display how much time is left until
+            // the message is deleted.
+            sql.execute(
+                "ALTER TABLE msgs ADD COLUMN ephemeral_timestamp INTEGER DEFAULT 0",
+                paramsv![],
+            )
+            .await?;
+            sql.set_raw_config_int(context, "dbversion", 65).await?;
+        }

        // (2) updates that require high-level objects
        // (the structure is complete now and all objects are usable)
@@ -1312,10 +1348,12 @@ mod test {
        maybe_add_file(&mut files, "$BLOBDIR/hello");
        maybe_add_file(&mut files, "$BLOBDIR/world.txt");
        maybe_add_file(&mut files, "world2.txt");
+        maybe_add_file(&mut files, "$BLOBDIR");

        assert!(files.contains("hello"));
        assert!(files.contains("world.txt"));
        assert!(!files.contains("world2.txt"));
+        assert!(!files.contains("$BLOBDIR"));
    }

    #[test]
--- a/src/stock.rs
+++ b/src/stock.rs
@@ -130,7 +130,9 @@ pub enum StockMessage {
    ))]
    AcSetupMsgBody = 43,

-    #[strum(props(fallback = "Cannot login as %1$s."))]
+    #[strum(props(
+        fallback = "Cannot login as \"%1$s\". Please check if the email address and the password are correct."
+    ))]
    CannotLogin = 60,

    #[strum(props(fallback = "Could not connect to %1$s: %2$s"))]
@@ -177,7 +179,7 @@ pub enum StockMessage {
                    however, of course, if they like, you may point them to 👉 https://get.delta.chat"))]
    WelcomeMessage = 71,

-    #[strum(props(fallback = "Unknown Sender for this chat. See 'info' for more details."))]
+    #[strum(props(fallback = "Unknown sender for this chat. See 'info' for more details."))]
    UnknownSenderForChat = 72,

    #[strum(props(fallback = "Message from %1$s"))]
@@ -185,6 +187,29 @@ pub enum StockMessage {

    #[strum(props(fallback = "Failed to send message to %1$s."))]
    FailedSendingTo = 74,
+
+    #[strum(props(fallback = "Message deletion timer is disabled."))]
+    MsgEphemeralTimerDisabled = 75,
+
+    // A fallback message for unknown timer values.
+    // "s" stands for "second" SI unit here.
+    #[strum(props(fallback = "Message deletion timer is set to %1$s s."))]
+    MsgEphemeralTimerEnabled = 76,
+
+    #[strum(props(fallback = "Message deletion timer is set to 1 minute."))]
+    MsgEphemeralTimerMinute = 77,
+
+    #[strum(props(fallback = "Message deletion timer is set to 1 hour."))]
+    MsgEphemeralTimerHour = 78,
+
+    #[strum(props(fallback = "Message deletion timer is set to 1 day."))]
+    MsgEphemeralTimerDay = 79,
+
+    #[strum(props(fallback = "Message deletion timer is set to 1 week."))]
+    MsgEphemeralTimerWeek = 80,
+
+    #[strum(props(fallback = "Message deletion timer is set to 4 weeks."))]
+    MsgEphemeralTimerFourWeeks = 81,
 }

 /*
@@ -334,10 +359,10 @@ impl Context {
        let action1 = action.trim_end_matches('.');
        match from_id {
            0 => action,
-            1 => {
+            DC_CONTACT_ID_SELF => {
                self.stock_string_repl_str(StockMessage::MsgActionByMe, action1)
                    .await
-            } // DC_CONTACT_ID_SELF
+            }
            _ => {
                let displayname = Contact::get_by_id(self, from_id)
                    .await
@@ -409,7 +434,7 @@ mod tests {

    #[async_std::test]
    async fn test_set_stock_translation() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        t.ctx
            .set_stock_translation(StockMessage::NoMessages, "xyz".to_string())
            .await
@@ -419,7 +444,7 @@ mod tests {

    #[async_std::test]
    async fn test_set_stock_translation_wrong_replacements() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        assert!(t
            .ctx
            .set_stock_translation(StockMessage::NoMessages, "xyz %1$s ".to_string())
@@ -434,7 +459,7 @@ mod tests {

    #[async_std::test]
    async fn test_stock_str() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        assert_eq!(
            t.ctx.stock_str(StockMessage::NoMessages).await,
            "No messages."
@@ -443,7 +468,7 @@ mod tests {

    #[async_std::test]
    async fn test_stock_string_repl_str() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        // uses %1$s substitution
        assert_eq!(
            t.ctx
@@ -456,7 +481,7 @@ mod tests {

    #[async_std::test]
    async fn test_stock_string_repl_int() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        assert_eq!(
            t.ctx
                .stock_string_repl_int(StockMessage::MsgAddMember, 42)
@@ -467,7 +492,7 @@ mod tests {

    #[async_std::test]
    async fn test_stock_string_repl_str2() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        assert_eq!(
            t.ctx
                .stock_string_repl_str2(StockMessage::ServerResponse, "foo", "bar")
@@ -478,7 +503,7 @@ mod tests {

    #[async_std::test]
    async fn test_stock_system_msg_simple() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        assert_eq!(
            t.ctx
                .stock_system_msg(StockMessage::MsgLocationEnabled, "", "", 0)
@@ -489,7 +514,7 @@ mod tests {

    #[async_std::test]
    async fn test_stock_system_msg_add_member_by_me() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        assert_eq!(
            t.ctx
                .stock_system_msg(
@@ -505,7 +530,7 @@ mod tests {

    #[async_std::test]
    async fn test_stock_system_msg_add_member_by_me_with_displayname() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        Contact::create(&t.ctx, "Alice", "alice@example.com")
            .await
            .expect("failed to create contact");
@@ -524,7 +549,7 @@ mod tests {

    #[async_std::test]
    async fn test_stock_system_msg_add_member_by_other_with_displayname() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let contact_id = {
            Contact::create(&t.ctx, "Alice", "alice@example.com")
                .await
@@ -548,7 +573,7 @@ mod tests {

    #[async_std::test]
    async fn test_stock_system_msg_grp_name() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        assert_eq!(
            t.ctx
                .stock_system_msg(
@@ -564,7 +589,7 @@ mod tests {

    #[async_std::test]
    async fn test_stock_system_msg_grp_name_other() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        let id = Contact::create(&t.ctx, "Alice", "alice@example.com")
            .await
            .expect("failed to create contact");
@@ -579,7 +604,7 @@ mod tests {

    #[async_std::test]
    async fn test_update_device_chats() {
-        let t = dummy_context().await;
+        let t = TestContext::new().await;
        t.ctx.update_device_chats().await.ok();
        let chats = Chatlist::try_load(&t.ctx, 0, None, None).await.unwrap();
        assert_eq!(chats.len(), 2);
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -18,44 +18,59 @@ pub(crate) struct TestContext {
    pub dir: TempDir,
 }

-/// Create a new, opened [TestContext] using given callback.
-///
-/// The [Context] will be opened with the SQLite database named
-/// "db.sqlite" in the [TestContext.dir] directory.
-///
-/// [Context]: crate::context::Context
-pub(crate) async fn test_context() -> TestContext {
-    let dir = tempdir().unwrap();
-    let dbfile = dir.path().join("db.sqlite");
-    let ctx = Context::new("FakeOs".into(), dbfile.into()).await.unwrap();
-    TestContext { ctx, dir }
-}
+impl TestContext {
+    /// Create a new [TestContext].
+    ///
+    /// The [Context] will be created and have an SQLite database named "db.sqlite" in the
+    /// [TestContext.dir] directory.  This directory is cleaned up when the [TestContext] is
+    /// dropped.
+    ///
+    /// [Context]: crate::context::Context
+    pub async fn new() -> Self {
+        let dir = tempdir().unwrap();
+        let dbfile = dir.path().join("db.sqlite");
+        let ctx = Context::new("FakeOS".into(), dbfile.into()).await.unwrap();
+        Self { ctx, dir }
+    }

-/// Return a dummy [TestContext].
-///
-/// The context will be opened and use the SQLite database as
-/// specified in [test_context] but there is no callback hooked up,
-/// i.e. [Context::call_cb] will always return `0`.
-pub(crate) async fn dummy_context() -> TestContext {
-    test_context().await
-}
+    /// Create a new configured [TestContext].
+    ///
+    /// This is a shortcut which automatically calls [TestContext::configure_alice] after
+    /// creating the context.
+    pub async fn new_alice() -> Self {
+        let t = Self::new().await;
+        t.configure_alice().await;
+        t
+    }

-pub(crate) async fn configured_offline_context() -> TestContext {
-    configured_offline_context_with_addr("alice@example.org").await
-}
+    /// Configure with alice@example.com.
+    ///
+    /// The context will be fake-configured as the alice user, with a pre-generated secret
+    /// key.  The email address of the user is returned as a string.
+    pub async fn configure_alice(&self) -> String {
+        let keypair = alice_keypair();
+        self.configure_addr(&keypair.addr.to_string()).await;
+        key::store_self_keypair(&self.ctx, &keypair, key::KeyPairUse::Default)
+            .await
+            .expect("Failed to save Alice's key");
+        keypair.addr.to_string()
+    }

-pub(crate) async fn configured_offline_context_with_addr(addr: &str) -> TestContext {
-    let t = dummy_context().await;
-    t.ctx.set_config(Config::Addr, Some(addr)).await.unwrap();
-    t.ctx
-        .set_config(Config::ConfiguredAddr, Some(addr))
-        .await
-        .unwrap();
-    t.ctx
-        .set_config(Config::Configured, Some("1"))
-        .await
-        .unwrap();
-    t
+    /// Configure as a given email address.
+    ///
+    /// The context will be configured but the key will not be pre-generated so if a key is
+    /// used the fingerprint will be different every time.
+    pub async fn configure_addr(&self, addr: &str) {
+        self.ctx.set_config(Config::Addr, Some(addr)).await.unwrap();
+        self.ctx
+            .set_config(Config::ConfiguredAddr, Some(addr))
+            .await
+            .unwrap();
+        self.ctx
+            .set_config(Config::Configured, Some("1"))
+            .await
+            .unwrap();
+    }
 }

 /// Load a pre-generated keypair for alice@example.com from disk.
@@ -78,20 +93,6 @@ pub(crate) fn alice_keypair() -> key::KeyPair {
    }
 }

-/// Creates Alice with a pre-generated keypair.
-///
-/// Returns the address of the keypair created (alice@example.com).
-pub(crate) async fn configure_alice_keypair(ctx: &Context) -> String {
-    let keypair = alice_keypair();
-    ctx.set_config(Config::ConfiguredAddr, Some(&keypair.addr.to_string()))
-        .await
-        .unwrap();
-    key::store_self_keypair(&ctx, &keypair, key::KeyPairUse::Default)
-        .await
-        .expect("Failed to save Alice's key");
-    keypair.addr.to_string()
-}
-
 /// Load a pre-generated keypair for bob@example.net from disk.
 ///
 /// Like [alice_keypair] but a different key and identity.
Author	SHA1	Message	Date
Simon Laux	439d09ebb5	add chat.get_summary (returns a lot like the original function chatlit.getsummary but it doesn't need a chatlist to work)	2020-07-15 22:51:21 +02:00
Alexander Krotov	667364b90e	Mark location-only messages as auto-generated	2020-07-15 02:16:20 +03:00
holger krekel	ef954ed99e	set_version now ensures lto = true, more logging	2020-07-14 23:46:36 +02:00
Alexander Krotov	7bb6890f26	Send MDNs for messages deleted on the server Now MarkseenMsgOnImap sends MDN even if it can't mark the message as seen on the server. To prevent multiple MDNs from being sent, MarkseenMsgOnImap is postponed until the message is detected in a folder from which it is not going to be moved.	2020-07-14 23:26:48 +03:00
Alexander Krotov	2aa808756e	Add test for MDN not sent for server deleted messages	2020-07-14 23:26:48 +03:00
Alexander Krotov	81a2e510f5	Move proxy.py from scripts/ to contrib/ This change makes it clear that core does not depend on this code.	2020-07-14 20:41:38 +02:00
B. Petersen	82a3af97df	adapt repl to new marker api and make it compile again	2020-07-13 18:34:37 +02:00
bjoern	f1b3527ad0	Merge pull request #1613 from deltachat/warn-wrong-pw Show a better toast and a notification when the password is wrong (because it was changed on the server)	2020-07-13 13:12:31 +02:00
Alexander Krotov	6902250d6b	securejoin: do not check the signatures existance twice Mimeparser.was_encrypted() checks if the message is an Autocrypt encrypted message. It already means the message has a valid signature. This commit documents a few functions to make it clear that signatures stored in Mimeparser must be valid and must always come from encrypted messages. Also one unwrap() is eliminated in encrypted_and_signed(). It is possible to further simplify encrypted_and_signed() by skipping the was_encrypted() check, because the function only returns true if there is a matching signature, but it is helpful for debugging to distinguish between non-Autocrypt messages and messages whose fingerprint does not match.	2020-07-13 12:36:14 +02:00
bjoern	64ab86a1a6	Merge pull request #1705 from deltachat/seen_ephemeral_timer Start ephemeral timer immediately for already seen messages	2020-07-13 02:21:22 +02:00
B. Petersen	4b445b7dd7	use time::SystemTime instead of time::Instant as the latter may use libc::clock_gettime(CLOCK_MONOTONIC) eg. on android and does not advance while being in deep sleep mode. therefore, time::Instant is not a reliable way for timeouts or stoping times.	2020-07-13 02:27:03 +03:00
Alexander Krotov	6cb75114c1	Cleanup test_basic_imap_api()	2020-07-13 01:53:28 +03:00
Alexander Krotov	d54ade5891	Start ephemeral timer for non-fresh messages	2020-07-13 01:20:16 +03:00
Alexander Krotov	0da21aa9f6	dc_receive_imf: rename timer into ephemeral_timer	2020-07-13 01:15:51 +03:00
Alexander Krotov	1e84e81e7d	imap: expunge folder before IDLE if needed This ensures Inbox is expunged timely in setups that don't watch DeltaChat folder.	2020-07-13 00:54:20 +03:00
Alexander Krotov	d3eb209d27	Add test for immediate server deletion	2020-07-13 00:54:20 +03:00
Alexander Krotov	49a6a5b23c	testplugin.py: print HTTP response text on error	2020-07-12 22:58:57 +03:00
Alexander Krotov	4f78e2e14e	Do not show an error on IMAP connection failure It is annoying as it happens every time the server is rebooted.	2020-07-12 17:17:26 +02:00
Alexander Krotov	7da69a4644	Add dc_msg_get_ephemeral_{timer, timestamp}()	2020-07-11 22:25:17 +03:00
Alexander Krotov	8efe7cade7	Rename part_mut into part	2020-07-11 21:43:02 +03:00
Alexander Krotov	18e4abc1df	Remove some and deny new indexing and slicing	2020-07-11 21:43:02 +03:00
Hocuri	ee7b7eb4f2	Once more, fix #1575 Messages sent by DeltaChat trigger spam filters due to incorrect/non-compliant formatting options	2020-07-11 21:10:06 +03:00
B. Petersen	4378fe21ee	delete now superfluous ASYNC-API-TODO.txt, the things are implemented that way :)	2020-07-11 18:26:42 +02:00
Hocuri	b50410ab15	Fix #1687	2020-07-11 17:38:48 +02:00
Hocuri	9f7567c1d1	Abort on failing imap configuring	2020-07-11 14:27:15 +02:00
Hocuri	68e3bce60e	Remove error!() from https://github.com/deltachat/deltachat-core-rust/pull/1539 it led to a less clear error message being shown when the configure failed.	2020-07-11 14:27:15 +02:00
Hocuri	86bc54508f	More explicit	2020-07-11 14:27:15 +02:00
Hocuri	ae2fd4014a	Emit Event::ErrorNetwork again	2020-07-11 14:27:15 +02:00
Hocuri	2c23433185	Make it work Add a mutex to prevent a race condition when a "your pw is wrong" warning is sent, resulting in multiple messeges being sent. Do not mute the device chat but "only" send MsgsChanged event when no notification shall be shown. More logging.	2020-07-11 14:27:15 +02:00
Hocuri	3f2e67f07a	First try for notification	2020-07-11 14:27:14 +02:00
Hocuri	06a4f15995	Better warning if the pw is wrong	2020-07-11 14:27:14 +02:00
Alexander Krotov	e2c532704a	Fix documentation typo	2020-07-11 00:04:38 +03:00
bjoern	baa0dffdfd	Merge pull request #1696 from deltachat/ephemeral-timer-modified-event Ephemeral timer modified event fix	2020-07-10 14:07:09 +02:00
Alexander Krotov	f28a0db7d0	Store typed timer in ChatEphemeralTimerModified event	2020-07-10 02:55:17 +03:00
Alexander Krotov	e5d5009d6a	Emit ChatEphemeralTimerModified when user changes the timer	2020-07-10 02:52:45 +03:00
bjoern	2071478e11	Merge pull request #1695 from deltachat/prep-1.40 prepare 1.40	2020-07-10 00:27:01 +02:00
B. Petersen	797375ff43	update changelog	2020-07-09 23:46:27 +02:00
B. Petersen	18045c9c14	bump version to 1.40	2020-07-09 23:42:23 +02:00
B. Petersen	14d09ce75f	update changelog for 1.40	2020-07-09 23:42:23 +02:00
Alexander Krotov	0ae8663eed	imap: call dc_receive_imf sequentially Parallel processing of messages results in bugs such as messages sent by a new member being processed before the message that adds this member to the chat, even when it has lower UID. In this case, messages are shown as "[Unknown sender for this chat. See 'info' for more details.]", while there is a message "Member ... added" right before, because writing the information about new member to the database takes longer then reading old index from the database.	2020-07-10 00:40:52 +03:00
Alexander Krotov	d1ec0e2de6	Fix Chatlist::try_load() doc comment	2020-07-09 23:19:33 +03:00
Alexander Krotov	7f8f871813	Make ephemeral timer changes not ephemeral	2020-07-08 20:25:05 +03:00
Alexander Krotov	43c4816739	Display source for IMAP IDLE errors	2020-07-08 01:32:49 +03:00
Alexander Krotov	1b5d08e6ee	Start ephemeral timers during housekeeping	2020-07-08 01:16:01 +03:00
Alexander Krotov	bb9603661a	Fix a typo	2020-07-07 22:38:50 +03:00
dignifiedquire	7d08397b48	cleanup interrupt and exit of imap idle	2020-07-07 16:09:13 +03:00
bjoern	3df0ef50a4	Merge pull request #1685 from deltachat/update-ffi-doc update ffi docs	2020-07-06 19:13:43 +02:00
B. Petersen	6a99e31de4	document the new option (see #1677 ) to get the reliable time of a DAYMARKER	2020-07-06 17:27:11 +02:00
Alexander Krotov	d9314227ee	Do not duplicate system messages about timer changes Instead, replace them with localized stock strings using set_better_msg.	2020-07-02 14:20:55 +03:00
Alexander Krotov	6050f0e2a1	Always schedule next ephemeral task after message deletion If no messages were deleted, it means the task was scheduled earlier then needed and should be rescheduled.	2020-07-01 22:18:36 +03:00
Alexander Krotov	d4dea0d5c6	Schedule ephemeral task 1 second later This accounts for 1-second rounding, otherwise the task is always too early.	2020-07-01 22:18:36 +03:00
Alexander Krotov	0b187131b2	Cargo.toml: disable LTO	2020-07-01 20:35:50 +03:00
Alexander Krotov	5a28b669f9	Set ephemeral timer for info messages	2020-07-01 20:32:37 +03:00
Alexander Krotov	d59475f9bb	Fix a typo in UnknownSenderForChat	2020-07-01 19:11:48 +03:00
Alexander Krotov	db6623d0cf	Add stock strings for ephemeral timer changes	2020-07-01 12:31:51 +03:00
Alexander Krotov	059caee527	Add "by me" to "Ephemeral message timer changed to" Otherwise this message looks different on other devices of the sender.	2020-07-01 12:31:51 +03:00
Alexander Krotov	97599bd78e	dc_array: remove unused binding	2020-07-01 12:31:11 +03:00
Alexander Krotov	d6b30c9703	Fix python test for ephemeral timer	2020-07-01 09:32:08 +03:00
Alexander Krotov	7a7dcc8b8f	constants.rs: remove unused DC_STR_* constants They are also outdated.	2020-07-01 07:55:22 +03:00
Alexander Krotov	d79c918c9e	Replace 1 with DC_CONTACT_ID_SELF	2020-07-01 00:59:07 +03:00
Alexander Krotov	56518420bc	Add get_marker method to dc_array_t	2020-06-30 01:21:18 +03:00
Alexander Krotov	615a76f35e	Add timestamp to DayMarker With this change, API user does not need to look at the timestamp of the next message to display the day marker, but can get the timestamp directly from the marker. This way there is no database query and no risk of error as a result of database being busy or message being deleted.	2020-06-30 01:21:18 +03:00
Alexander Krotov	0c47489a3b	Use ephemeral::Timer in MsgId.ephemeral_timer() method	2020-06-29 23:04:34 +03:00
Alexander Krotov	f931a905a7	Remove useless comment	2020-06-29 23:04:34 +03:00
Alexander Krotov	7d048ac419	Add autodelete timers	2020-06-29 23:04:34 +03:00
Alexander Krotov	41fe3db79d	Add ChatItem type ChatItem can represent markers as enum variants instead of special MsgIds.	2020-06-29 00:30:17 +03:00
Alexander Krotov	42f6a7c77c	Remove dc_array_get_raw It does not work with typed arrays, such as locations and messages. Use dc_array_get_id in a loop instead.	2020-06-26 01:22:10 +03:00
Alexander Krotov	09833eb74d	dc_array: introduce MsgIds variant This avoids allocation of u32 vector.	2020-06-26 01:22:10 +03:00
Alexander Krotov	2c11df46a7	dc_array: remove unnecessary "as u32" cast	2020-06-26 01:22:10 +03:00
Alexander Krotov	443ad04f46	Mark all dc_array method as pub(crate) This make it easier to find unused methods.	2020-06-26 01:22:10 +03:00
Alexander Krotov	f2d09cc51e	dc_array: simplify and test search_id This also makes it possible to search for location IDs.	2020-06-26 01:22:10 +03:00
Alexander Krotov	83dde57afa	Remove unused dc_array methods	2020-06-26 01:22:10 +03:00
Alexander Krotov	fdacf98b69	handle_mdn: compare from_id to DC_CONTACT_ID_LAST_SPECIAL DC_MSG_ID_LAST_SPECIAL has the same value, but from_id is not a msg id.	2020-06-26 01:11:15 +03:00
bjoern	9152f93a46	Merge pull request #1668 from deltachat/add-sanitise-tests add more tests for BlobObject::sanitise_name()	2020-06-23 19:04:51 +02:00
bjoern	6a4b6fddac	Merge pull request #1659 from deltachat/prep-1.39 prepare 1.39	2020-06-23 19:01:36 +02:00
B. Petersen	e3c90aff22	add more tests for BlobObject::sanitise_name()	2020-06-23 18:51:40 +02:00
B. Petersen	b7464f7a5c	bump version to 1.39	2020-06-23 18:41:45 +02:00
B. Petersen	53128cc64b	update changelog for 1.39 and fix the one for 1.36	2020-06-23 18:41:45 +02:00
bjoern	ccf8eeacd6	Merge pull request #1667 from deltachat/revert-1664-sanitize-filename-reader-friendly Revert "Switch to sanitize-filename-reader-friendly"	2020-06-23 18:40:40 +02:00
bjoern	aeb8a2e260	Revert "Switch to sanitize-filename-reader-friendly" This reverts commit `93797bc82f`.	2020-06-23 18:11:18 +02:00
Alexander Krotov	93797bc82f	Switch to sanitize-filename-reader-friendly One advantage is that it does not depend on any crates, so there is a higher chance of dropping regex crate eventually.	2020-06-23 14:37:35 +03:00
holger krekel	07236efc45	fix bcc_self to remain "0" for testrun/fivechat test accounts	2020-06-23 08:06:32 +02:00
B. Petersen	0fbddc939b	update provider-db	2020-06-23 08:06:32 +02:00
Alexander Krotov	a031151587	Fix two +nightly clippy suggestions	2020-06-23 03:17:07 +03:00
B. Petersen	545ff4f7ba	apply config_defaults only for unset values instead of applying all config_defaults unconditionally after the first configure, a config_defaults for a given key is now applied when this key has never been set before. this way, you can set some keys before calling configure() and also, later versions can add new defaults for new keys (that would require another call to configure() then, however)	2020-06-23 00:48:40 +02:00
B. Petersen	73e695537a	add missing doc for bcc_self	2020-06-22 22:49:26 +02:00
B. Petersen	16e3c113b7	update ffi docs; avatar is sent with messages since end 2019	2020-06-22 22:49:26 +02:00
bjoern	88d7bf49ff	Merge pull request #1658 from deltachat/remove-config-changes-interrupt remove config changes interrupt	2020-06-22 14:18:48 +02:00
B. Petersen	74ea884aa4	remove now superfluous interrupting on watch-settings-changes	2020-06-22 13:48:33 +02:00
B. Petersen	16c53637d9	update docs to new watch-settings behavior	2020-06-22 13:47:47 +02:00
Friedel Ziegelmayer	f63f0550b0	Merge pull request #1654 from deltachat/fix-move-loops fix(scheduler): only start watch loops if the appropriate config is set	2020-06-22 12:51:43 +02:00
Friedel Ziegelmayer	530503932b	Merge pull request #1655 from deltachat/feat-update-deps feat: update deps	2020-06-22 12:23:26 +02:00
Friedel Ziegelmayer	d2dc4edd82	Merge pull request #1657 from deltachat/fix-move-loops-inbox perform jobs also if inbox_watch disabled	2020-06-22 12:23:10 +02:00
Alexander Krotov	8de1bc6cbd	sql: fix potential panic in maybe_add_file When maybe_add_file was called with "$BLOBDIR" it tried to remove 9 bytes from the string, while it only contains 8.	2020-06-22 13:22:37 +03:00
B. Petersen	76e39bfa7c	this pr creates the inbox_loop inpendendingly of inbox_watch config-setting as the loop is also required to perform jobs. the config-setting is checked inside the loop then	2020-06-22 12:00:25 +02:00
Alexander Krotov	cf09942737	deltachat-ffi: use as_deref() as suggested by clippy	2020-06-22 12:37:29 +03:00
dignifiedquire	6fe1f01c5f	feat: update deps includes async-std@1.6.2 and smol@0.1.18 which fix various hangs and possible deadlocks	2020-06-22 10:04:10 +02:00
dignifiedquire	f880d6188b	fix(scheduler): only start watch loops if the appropriate config is set	2020-06-22 10:00:50 +02:00
bjoern	22c62ea6af	Merge pull request #1649 from deltachat/freepascal README: add link to Free Pascal bindings	2020-06-21 21:52:51 +02:00
Alexander Krotov	e3af3a24a8	README: add link to Free Pascal bindings	2020-06-21 20:14:30 +03:00
Alexander Krotov	7bfadb14ea	Fix a typo (prover -> provider)	2020-06-21 20:13:06 +03:00
bjoern	75d20b899a	Merge pull request #1646 from deltachat/prep-1.38 prepare 1.38	2020-06-21 12:12:02 +02:00
B. Petersen	31a5811241	bump version to 1.38	2020-06-20 19:16:07 +02:00
B. Petersen	cd1f5bf229	update changelog for 1.38	2020-06-20 19:09:33 +02:00
bjoern	632fc19f41	Merge pull request #1645 from deltachat/correct-seen give correct "fresh" flag to calc_sort_timestamp()	2020-06-20 19:05:34 +02:00
B. Petersen	7ad95ea165	give correct "fresh" flag to calc_sort_timestamp() for "fresh" messages, calc_sort_timestamp() makes sure, the sorting timestamp is not less than the last-non-fresh message. this commit fixes the "fresh" state we give to calc_sort_timestamp(), it just uses the message-state we've already calculated. the old assumption, that unseen messages are always fresh is wrong as this "seen" flag just comes from an imap-flag that is not set for self-sent messages. therefore, in a multi-device-setup, things are totally messed up. (the bug was probably in there since a long time, however did not came to light until the async-move)	2020-06-20 18:36:09 +02:00
Floris Bruynooghe	9d7b756ddb	Unify some testing interfaces This tidies up our testing tools a little bit. We had several functions which through various changes ended up doing the same and some more which did very similar stuff, so I merged them to have things simpler. Also moved towards methods on the TestContext struct while cleaning this up anyway, seems like this structure is going to stay around for a bit anyway. The intersting change is in `test_utils.rs`, everything else is just updating callers. A few tests used example.org which I moved to example.com to be able to re-use more configuration of the test context.	2020-06-20 14:37:41 +02:00
bjoern	73412db267	Merge pull request #1644 from deltachat/stop-time-in-repl print time needed to build chatlist in repl tool	2020-06-20 13:07:50 +02:00
B. Petersen	059a7bcd7f	print time needed to build chatlist in repl tool the chatlist is the most complicated list to get from sql and is also the most used list, so it makes sense to keep an eye on the timing of that.	2020-06-20 00:56:43 +02:00
bjoern	3e47564b2f	Merge pull request #1643 from deltachat/prep-1.37 prepare 1.37	2020-06-19 21:54:04 +02:00