wip

.circleci/config.yml

@@ -15,7 +15,7 @@ restore-workspace: &restore-workspace
 restore-cache: &restore-cache
   restore_cache:
     keys:
-      - cargo-v3-{{ checksum "rust-toolchain" }}-{{ checksum "Cargo.toml" }}-{{ checksum "Cargo.lock" }}-{{ arch }}
+      - cargo-v2-{{ checksum "rust-toolchain" }}-{{ checksum "Cargo.toml" }}-{{ checksum "Cargo.lock" }}-{{ arch }}
       - repo-source-{{ .Branch }}-{{ .Revision }}
 
 commands:
@@ -44,7 +44,7 @@ jobs:
           command: cargo generate-lockfile
       - restore_cache:
           keys:
-            - cargo-v3-{{ checksum "rust-toolchain" }}-{{ checksum "Cargo.toml" }}-{{ checksum "Cargo.lock" }}-{{ arch }}
+            - cargo-v2-{{ checksum "rust-toolchain" }}-{{ checksum "Cargo.toml" }}-{{ checksum "Cargo.lock" }}-{{ arch }}
       - run: rustup install $(cat rust-toolchain)
       - run: rustup default $(cat rust-toolchain)
       - run: rustup component add --toolchain $(cat rust-toolchain) rustfmt
@@ -60,7 +60,7 @@ jobs:
           paths:
             - crate
       - save_cache:
-          key: cargo-v3-{{ checksum "rust-toolchain" }}-{{ checksum "Cargo.toml" }}-{{ checksum "Cargo.lock" }}-{{ arch }}
+          key: cargo-v2-{{ checksum "rust-toolchain" }}-{{ checksum "Cargo.toml" }}-{{ checksum "Cargo.lock" }}-{{ arch }}
           paths:
             - "~/.cargo"
             - "~/.rustup"
@@ -121,7 +121,7 @@ jobs:
     steps:
       - checkout
       - run: bash ci_scripts/run-doxygen.sh
-      - run: mkdir -p workspace/c-docs
+      - run: mkdir -p workspace/c-docs 
       - run: cp -av deltachat-ffi/{html,xml} workspace/c-docs/
       - persist_to_workspace:
           root: workspace
@@ -189,7 +189,7 @@ workflows:
       - upload_docs_wheels:
           requires:
             - build_test_docs_wheel
-            - build_doxygen
+            - build_doxygen 
       - rustfmt:
           requires:
             - cargo_fetch

.github/workflows/rust.yml

@@ -1,30 +0,0 @@
-name: CI
-
-on:
-  pull_request:
-  push:
-
-env:
-  RUSTFLAGS: -Dwarnings
-
-jobs:
-  build:
-    name: 3.7 python tests against core
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@master
-
-      - uses: actions-rs/toolchain@v1
-        with:
-           profile: minimal
-           toolchain: nightly
-           override: true
-           components: rustfmt
-
-      - name: Setup python
-        uses: actions/setup-python@v1
-        with:
-          python-version: 3.x
-          architecture: x64
-
-      - run: bash ci_scripts/run-python.sh 

Cargo.toml

@@ -15,13 +15,12 @@ hex = "0.3.2"
 sha2 = "0.8.0"
 rand = "0.6.5"
 smallvec = "0.6.9"
-reqwest = { version = "0.9.15", default-features = false, features = ["rustls-tls"] }
+reqwest = "0.9.15"
 num-derive = "0.2.5"
 num-traits = "0.2.6"
-lettre = { git = "https://github.com/deltachat/lettre", branch = "feat/rustls" }
-async-imap = "0.1"
-async-tls = "0.6"
-async-std = { version = "1.0", features = ["unstable"] }
+native-tls = "0.2.3"
+lettre = { git = "https://github.com/deltachat/lettre", branch = "master" }
+imap = { git = "https://github.com/deltachat/rust-imap", branch = "master" }
 base64 = "0.10"
 charset = "0.1"
 percent-encoding = "2.0"
@@ -50,10 +49,6 @@ bitflags = "1.1.0"
 jetscii = "0.4.4"
 debug_stub_derive = "0.3.0"
 sanitize-filename = "0.2.1"
-stop-token = { version = "0.1.1", features = ["unstable"] }
-rustls = "0.16.0"
-webpki-roots = "0.18.0"
-webpki = "0.21.0"
 
 [dev-dependencies]
 tempfile = "3.0"
@@ -79,6 +74,6 @@ path = "examples/repl/main.rs"
 
 [features]
 default = ["nightly", "ringbuf"]
-vendored = []
+vendored = ["native-tls/vendored", "reqwest/default-tls-vendored"]
 nightly = ["pgp/nightly"]
 ringbuf = ["pgp/ringbuf"]

ci_scripts/docker-coredeps/Dockerfile

@@ -5,6 +5,16 @@ RUN echo /usr/local/lib64 > /etc/ld.so.conf.d/local.conf && \
     echo /usr/local/lib >> /etc/ld.so.conf.d/local.conf
 ENV PKG_CONFIG_PATH /usr/local/lib64/pkgconfig:/usr/local/lib/pkgconfig
 
+ENV PIP_DISABLE_PIP_VERSION_CHECK 1
+
+# Install python tools (auditwheels,tox, ...)
+ADD deps/build_python.sh /builder/build_python.sh
+RUN mkdir tmp1 && cd tmp1 && bash /builder/build_python.sh && cd .. && rm -r tmp1
+
+# Install Rust nightly 
+ADD deps/build_rust.sh /builder/build_rust.sh
+RUN mkdir tmp1 && cd tmp1 && bash /builder/build_rust.sh && cd .. && rm -r tmp1
+
 # Install a recent Perl, needed to install OpenSSL
 ADD deps/build_perl.sh /builder/build_perl.sh
 RUN mkdir tmp1 && cd tmp1 && bash /builder/build_perl.sh && cd .. && rm -r tmp1
@@ -13,12 +23,3 @@ RUN mkdir tmp1 && cd tmp1 && bash /builder/build_perl.sh && cd .. && rm -r tmp1
 ADD deps/build_openssl.sh /builder/build_openssl.sh
 RUN mkdir tmp1 && cd tmp1 && bash /builder/build_openssl.sh && cd .. && rm -r tmp1
 
-ENV PIP_DISABLE_PIP_VERSION_CHECK 1
-
-# Install python tools (auditwheels,tox, ...)
-ADD deps/build_python.sh /builder/build_python.sh
-RUN mkdir tmp1 && cd tmp1 && bash /builder/build_python.sh && cd .. && rm -r tmp1
-
-# Install Rust nightly
-ADD deps/build_rust.sh /builder/build_rust.sh
-RUN mkdir tmp1 && cd tmp1 && bash /builder/build_rust.sh && cd .. && rm -r tmp1

ci_scripts/docker-coredeps/deps/build_perl.sh

@@ -1,11 +1,11 @@
 #!/bin/bash
 
-PERL_VERSION=5.30.0
-# PERL_SHA256=7e929f64d4cb0e9d1159d4a59fc89394e27fa1f7004d0836ca0d514685406ea8
+PERL_VERSION=5.28.0
+PERL_SHA256=7e929f64d4cb0e9d1159d4a59fc89394e27fa1f7004d0836ca0d514685406ea8
 curl -O https://www.cpan.org/src/5.0/perl-${PERL_VERSION}.tar.gz
-# echo "${PERL_SHA256}  perl-${PERL_VERSION}.tar.gz" | sha256sum -c -
-tar -xzf perl-${PERL_VERSION}.tar.gz
-cd perl-${PERL_VERSION}
+echo "${PERL_SHA256}  perl-${PERL_VERSION}.tar.gz" | sha256sum -c -
+tar xzf perl-${PERL_VERSION}.tar.gz
+cd perl-${PERL_VERSION} 
 
 ./Configure -de
 make

ci_scripts/docker-coredeps/deps/build_rust.sh

@@ -1,8 +1,11 @@
 #!/bin/bash
 
-set -e -x
+set -e -x 
 
-# Install Rust
-curl https://sh.rustup.rs -sSf | sh -s -- --default-toolchain nightly-2019-09-12 -y
+# Install Rust 
+curl https://sh.rustup.rs -sSf | sh -s -- --default-toolchain nightly-2019-07-10 -y
 export PATH=/root/.cargo/bin:$PATH
 rustc --version
+
+# remove some 300-400 MB that we don't need for automated builds
+rm -rf /root/.rustup/toolchains/nightly-2019-07-10-x86_64-unknown-linux-gnu/share/

ci_scripts/run-python.sh

@@ -13,6 +13,7 @@ export TOXWORKDIR=.docker-tox
 
 export PATH=/root/.cargo/bin:$PATH
 cargo build --release -p deltachat_ffi
+# cargo test --all --all-features
 
 # Statically link against libdeltachat.a.
 export DCC_RS_DEV=$(pwd)
@@ -21,27 +22,36 @@ export DCC_RS_DEV=$(pwd)
 # needed by tox below.
 export PATH=$PATH:/opt/python/cp35-cp35m/bin
 export PYTHONDONTWRITEBYTECODE=1
-
-pushd python
-# prepare a clean tox run
-rm -rf tests/__pycache__
-rm -rf src/deltachat/__pycache__
-export PYTHONDONTWRITEBYTECODE=1
-
-# run tox. The circle-ci project env-var-setting DCC_PY_LIVECONFIG 
-# allows running of "liveconfig" tests but for speed reasons
-# we run them only for the highest python version we support
-
-# we split out qr-tests run to minimize likelyness of flaky tests
-# (some qr tests are pretty heavy in terms of send/received
-# messages and rust's imap code likely has concurrency problems) 
-tox --workdir "$TOXWORKDIR" -e py37 -- --reruns 3 -k "not qr"
-tox --workdir "$TOXWORKDIR" -e py37 -- --reruns 3 -k "qr"
-unset DCC_PY_LIVECONFIG
-#tox --workdir "$TOXWORKDIR" -p4 -e lint,py35,py36,doc
-#tox --workdir "$TOXWORKDIR" -e auditwheels
+pushd /bin
+ln -s /opt/python/cp27-cp27m/bin/python2.7
+ln -s /opt/python/cp36-cp36m/bin/python3.6
+ln -s /opt/python/cp37-cp37m/bin/python3.7
 popd
 
+if [ -n "$TESTS" ]; then
+
+    pushd python
+    # prepare a clean tox run
+    rm -rf tests/__pycache__
+    rm -rf src/deltachat/__pycache__
+    export PYTHONDONTWRITEBYTECODE=1
+
+    # run tox. The circle-ci project env-var-setting DCC_PY_LIVECONFIG 
+    # allows running of "liveconfig" tests but for speed reasons
+    # we run them only for the highest python version we support
+    
+    # we split out qr-tests run to minimize likelyness of flaky tests
+    # (some qr tests are pretty heavy in terms of send/received
+    # messages and rust's imap code likely has concurrency problems) 
+    tox --workdir "$TOXWORKDIR" -e py37 -- --reruns 3 -k "not qr"
+    tox --workdir "$TOXWORKDIR" -e py37 -- --reruns 3 -k "qr"
+    unset DCC_PY_LIVECONFIG
+    tox --workdir "$TOXWORKDIR" -p4 -e lint,py35,py36,doc
+    tox --workdir "$TOXWORKDIR" -e auditwheels
+    popd
+fi
+
+
 # if [ -n "$DOCS" ]; then
 #     echo -----------------------
 #     echo generating python docs

deltachat-ffi/deltachat.h

@@ -501,9 +501,15 @@ char*           dc_get_oauth2_url            (dc_context_t* context, const char*
  * To interrupt a configuration prematurely, use dc_stop_ongoing_process();
  * this is not needed if #DC_EVENT_CONFIGURE_PROGRESS reports success.
  *
- * If #DC_EVENT_CONFIGURE_PROGRESS reports failure,
- * the core continues to use the last working configuration
- * and parameters as `addr`, `mail_pw` etc. are set to that.
+ * On a successfull configuration,
+ * the core makes a copy of the parameters mentioned above:
+ * the original parameters as are never modified by the core.
+ *
+ * UI-implementors should keep this in mind -
+ * eg. if the UI wants to prefill a configure-edit-dialog with these parameters,
+ * the UI should reset them if the user cancels the dialog
+ * after a configure-attempts has failed.
+ * Otherwise the parameters may not reflect the current configuation.
  *
  * @memberof dc_context_t
  * @param context The context object as created by dc_context_new().
@@ -4467,8 +4473,7 @@ void            dc_array_add_id              (dc_array_t*, uint32_t); // depreca
 #define DC_STR_MSGLOCATIONDISABLED        65
 #define DC_STR_LOCATION                   66
 #define DC_STR_STICKER                    67
-#define DC_STR_DEVICE_MESSAGES            68
-#define DC_STR_COUNT                      68
+#define DC_STR_COUNT                      67
 
 /*
  * @}

examples/repl/cmdline.rs

@@ -192,7 +192,7 @@ unsafe fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
     let msgtext = msg.get_text();
     info!(
         context,
-        "{}{}{}{}: {} (Contact#{}): {} {}{}{}{}{} [{}]",
+        "{}#{}{}{}: {} (Contact#{}): {} {}{}{}{}{} [{}]",
         prefix.as_ref(),
         msg.get_id(),
         if msg.get_showpadlock() { "🔒" } else { "" },
@@ -240,7 +240,7 @@ unsafe fn log_msglist(context: &Context, msglist: &Vec<MsgId>) -> Result<(), Err
                 lines_out += 1
             }
             let msg = Message::load_from_db(context, msg_id)?;
-            log_msg(context, "", &msg);
+            log_msg(context, "Msg", &msg);
         }
     }
     if lines_out > 0 {
@@ -426,12 +426,12 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
             if msg.is_setupmessage() {
                 let setupcodebegin = msg.get_setupcodebegin(context);
                 println!(
-                    "The setup code for setup message {} starts with: {}",
+                    "The setup code for setup message Msg#{} starts with: {}",
                     msg_id,
                     setupcodebegin.unwrap_or_default(),
                 );
             } else {
-                bail!("{} is no setup message.", msg_id,);
+                bail!("Msg#{} is no setup message.", msg_id,);
             }
         }
         "continue-key-transfer" => {
@@ -726,7 +726,7 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
                 let marker = location.marker.as_ref().unwrap_or(&default_marker);
                 info!(
                     context,
-                    "Loc#{}: {}: lat={} lng={} acc={} Chat#{} Contact#{} {} {}",
+                    "Loc#{}: {}: lat={} lng={} acc={} Chat#{} Contact#{} Msg#{} {}",
                     location.location_id,
                     dc_timestamp_to_str(location.timestamp),
                     location.latitude,
@@ -852,9 +852,9 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
             println!("{} images or videos: ", images.len());
             for (i, data) in images.iter().enumerate() {
                 if 0 == i {
-                    print!("{}", data);
+                    print!("Msg#{}", data);
                 } else {
-                    print!(", {}", data);
+                    print!(", Msg#{}", data);
                 }
             }
             print!("\n");

python/src/deltachat/account.py

@@ -490,12 +490,15 @@ class Account(object):
             self._threads.stop(wait=wait)
 
     def shutdown(self, wait=True):
+        print("SHUTDOWN", self)
         """ stop threads and close and remove underlying dc_context and callbacks. """
         if hasattr(self, "_dc_context") and hasattr(self, "_threads"):
-            # print("SHUTDOWN", self)
-            self.stop_threads(wait=False)
+            print("stop_threads", self)
+            self.stop_threads(wait=wait)
+            print("close", self)
             lib.dc_close(self._dc_context)
-            self.stop_threads(wait=wait)  # to wait for threads
+            print("clear", self)
+            #self.stop_threads(wait=wait)  # to wait for threads
             deltachat.clear_context_callback(self._dc_context)
             del self._dc_context
             atexit.unregister(self.shutdown)
@@ -567,37 +570,45 @@ class IOThreads:
         lib.dc_interrupt_sentbox_idle(self._dc_context)
         if wait:
             for name, thread in self._name2thread.items():
+                print("joining", name)
                 thread.join()
 
     def imap_thread_run(self):
         self._log_event("py-bindings-info", 0, "INBOX THREAD START")
         while not self._thread_quitflag:
             lib.dc_perform_imap_jobs(self._dc_context)
-            lib.dc_perform_imap_fetch(self._dc_context)
-            lib.dc_perform_imap_idle(self._dc_context)
+            if not self._thread_quitflag:
+                lib.dc_perform_imap_fetch(self._dc_context)
+            if not self._thread_quitflag:
+                lib.dc_perform_imap_idle(self._dc_context)
         self._log_event("py-bindings-info", 0, "INBOX THREAD FINISHED")
 
     def mvbox_thread_run(self):
         self._log_event("py-bindings-info", 0, "MVBOX THREAD START")
         while not self._thread_quitflag:
             lib.dc_perform_mvbox_jobs(self._dc_context)
-            lib.dc_perform_mvbox_fetch(self._dc_context)
-            lib.dc_perform_mvbox_idle(self._dc_context)
+            if not self._thread_quitflag:
+                lib.dc_perform_mvbox_fetch(self._dc_context)
+            if not self._thread_quitflag:
+                lib.dc_perform_mvbox_idle(self._dc_context)
         self._log_event("py-bindings-info", 0, "MVBOX THREAD FINISHED")
 
     def sentbox_thread_run(self):
         self._log_event("py-bindings-info", 0, "SENTBOX THREAD START")
         while not self._thread_quitflag:
             lib.dc_perform_sentbox_jobs(self._dc_context)
-            lib.dc_perform_sentbox_fetch(self._dc_context)
-            lib.dc_perform_sentbox_idle(self._dc_context)
+            if not self._thread_quitflag:
+                lib.dc_perform_sentbox_fetch(self._dc_context)
+            if not self._thread_quitflag:
+                lib.dc_perform_sentbox_idle(self._dc_context)
         self._log_event("py-bindings-info", 0, "SENTBOX THREAD FINISHED")
 
     def smtp_thread_run(self):
         self._log_event("py-bindings-info", 0, "SMTP THREAD START")
         while not self._thread_quitflag:
             lib.dc_perform_smtp_jobs(self._dc_context)
-            lib.dc_perform_smtp_idle(self._dc_context)
+            if not self._thread_quitflag:
+                lib.dc_perform_smtp_idle(self._dc_context)
         self._log_event("py-bindings-info", 0, "SMTP THREAD FINISHED")
 
 

python/tests/test_account.py

@@ -642,7 +642,7 @@ class TestOnlineAccount:
         assert os.path.exists(msg_in.filename)
         assert os.stat(msg_in.filename).st_size == os.stat(path).st_size
 
-    def test_import_export_online_all(self, acfactory, tmpdir, lp):
+    def test_import_export_online_all_twice(self, acfactory, tmpdir, lp):
         ac1 = acfactory.get_online_configuring_account()
         wait_configuration_progress(ac1, 1000)
 
@@ -895,7 +895,7 @@ class TestOnlineConfigureFails:
         ac1.start_threads()
         wait_configuration_progress(ac1, 500)
         ev1 = ac1._evlogger.get_matching("DC_EVENT_ERROR_NETWORK")
-        assert "cannot login" in ev1[2].lower()
+        assert "authentication failed" in ev1[2].lower()
         wait_configuration_progress(ac1, 0, 0)
 
     def test_invalid_user(self, acfactory):
@@ -904,7 +904,7 @@ class TestOnlineConfigureFails:
         ac1.start_threads()
         wait_configuration_progress(ac1, 500)
         ev1 = ac1._evlogger.get_matching("DC_EVENT_ERROR_NETWORK")
-        assert "cannot login" in ev1[2].lower()
+        assert "authentication failed" in ev1[2].lower()
         wait_configuration_progress(ac1, 0, 0)
 
     def test_invalid_domain(self, acfactory):

rust-toolchain

@@ -1 +1 @@
-nightly-2019-11-06
+nightly-2019-08-13

src/chatlist.rs

@@ -126,7 +126,7 @@ impl Chatlist {
                     "               SELECT MAX(timestamp)",
                     "                 FROM msgs",
                     "                WHERE chat_id=c.id",
-                    "                  AND hidden=0)",
+                    "                  AND (hidden=0 OR (hidden=1 AND state=19)))",
                     " WHERE c.id>9",
                     "   AND c.blocked=0",
                     "   AND c.id IN(SELECT chat_id FROM chats_contacts WHERE contact_id=?)",
@@ -149,7 +149,7 @@ impl Chatlist {
                     "               SELECT MAX(timestamp)",
                     "                 FROM msgs",
                     "                WHERE chat_id=c.id",
-                    "                  AND hidden=0)",
+                    "                  AND (hidden=0 OR (hidden=1 AND state=19)))",
                     " WHERE c.id>9",
                     "   AND c.blocked=0",
                     "   AND c.archived=1",
@@ -175,7 +175,7 @@ impl Chatlist {
                     "               SELECT MAX(timestamp)",
                     "                 FROM msgs",
                     "                WHERE chat_id=c.id",
-                    "                  AND hidden=0)",
+                    "                  AND (hidden=0 OR (hidden=1 AND state=19)))",
                     " WHERE c.id>9",
                     "   AND c.blocked=0",
                     "   AND c.name LIKE ?",
@@ -198,7 +198,7 @@ impl Chatlist {
                     "               SELECT MAX(timestamp)",
                     "                 FROM msgs",
                     "                WHERE chat_id=c.id",
-                    "                  AND hidden=0)",
+                    "                  AND (hidden=0 OR (hidden=1 AND state=19)))",
                     " WHERE c.id>9",
                     "   AND c.blocked=0",
                     "   AND c.archived=0",
@@ -294,7 +294,7 @@ impl Chatlist {
         let lastmsg_id = self.ids[index].1;
         let mut lastcontact = None;
 
-        let mut lastmsg = if let Ok(lastmsg) = Message::load_from_db(context, lastmsg_id) {
+        let lastmsg = if let Ok(lastmsg) = Message::load_from_db(context, lastmsg_id) {
             if lastmsg.from_id != DC_CONTACT_ID_SELF
                 && (chat.typ == Chattype::Group || chat.typ == Chattype::VerifiedGroup)
             {
@@ -306,16 +306,6 @@ impl Chatlist {
             None
         };
 
-        if let Ok(draft) = get_draft(context, chat.id) {
-            if draft.is_some()
-                && (lastmsg.is_none()
-                    || draft.as_ref().unwrap().timestamp_sort
-                        > lastmsg.as_ref().unwrap().timestamp_sort)
-            {
-                lastmsg = draft;
-            }
-        }
-
         if chat.id == DC_CHAT_ID_ARCHIVED_LINK {
             ret.text2 = None;
         } else if lastmsg.is_none() || lastmsg.as_ref().unwrap().from_id == DC_CONTACT_ID_UNDEFINED

src/configure/mod.rs

@@ -62,16 +62,16 @@ pub fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
 
     let mut param_autoconfig: Option<LoginParam> = None;
 
-    context.inbox.read().unwrap().disconnect(context);
+    context.inbox.write().unwrap().disconnect(context);
     context
         .sentbox_thread
-        .read()
+        .write()
         .unwrap()
         .imap
         .disconnect(context);
     context
         .mvbox_thread
-        .read()
+        .write()
         .unwrap()
         .imap
         .disconnect(context);
@@ -357,7 +357,7 @@ pub fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
                 };
                 context
                     .inbox
-                    .read()
+                    .write()
                     .unwrap()
                     .configure_folders(context, flags);
                 true
@@ -398,7 +398,7 @@ pub fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
         }
     }
     if imap_connected_here {
-        context.inbox.read().unwrap().disconnect(context);
+        context.inbox.write().unwrap().disconnect(context);
     }
     if smtp_connected_here {
         context.smtp.clone().lock().unwrap().disconnect();
@@ -421,16 +421,6 @@ pub fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context) {
         );
     }
     */
-
-    // remember the entered parameters on success
-    // and restore to last-entered on failure.
-    // this way, the parameters visible to the ui are always in-sync with the current configuration.
-    if success {
-        LoginParam::from_database(context, "").save_to_database(context, "configured_raw_");
-    } else {
-        LoginParam::from_database(context, "configured_raw_").save_to_database(context, "");
-    }
-
     context.free_ongoing();
     progress!(context, if success { 1000 } else { 0 });
 }
@@ -494,7 +484,7 @@ fn try_imap_one_param(context: &Context, param: &LoginParam) -> Option<bool> {
         param.mail_user, param.mail_server, param.mail_port, param.server_flags
     );
     info!(context, "Trying: {}", inf);
-    if context.inbox.read().unwrap().connect(context, &param) {
+    if context.inbox.write().unwrap().connect(context, &param) {
         info!(context, "success: {}", inf);
         return Some(true);
     }
@@ -566,10 +556,10 @@ fn try_smtp_one_param(context: &Context, param: &LoginParam) -> Option<bool> {
 /*******************************************************************************
  * Connect to configured account
  ******************************************************************************/
-pub fn dc_connect_to_configured_imap(context: &Context, imap: &Imap) -> libc::c_int {
+pub fn dc_connect_to_configured_imap(context: &Context, imap: &mut Imap) -> libc::c_int {
     let mut ret_connected = 0;
 
-    if async_std::task::block_on(async move { imap.is_connected().await }) {
+    if imap.is_connected() {
         ret_connected = 1
     } else if !context.sql.get_raw_config_bool(context, "configured") {
         warn!(context, "Not configured, cannot connect.",);

src/context.rs

@@ -43,6 +43,7 @@ pub struct Context {
     blobdir: PathBuf,
     pub sql: Sql,
     pub inbox: Arc<RwLock<Imap>>,
+    pub(crate) inbox_watch: Arc<(Mutex<bool>, Condvar)>,
     pub perform_inbox_jobs_needed: Arc<RwLock<bool>>,
     pub probe_imap_network: Arc<RwLock<bool>>,
     pub sentbox_thread: Arc<RwLock<JobThread>>,
@@ -115,10 +116,15 @@ impl Context {
             "Blobdir does not exist: {}",
             blobdir.display()
         );
+
+        let inbox_watch = Arc::new((Mutex::new(false), Condvar::new()));
+        let inbox = Arc::new(RwLock::new(Imap::new(inbox_watch.clone())));
+
         let ctx = Context {
             blobdir,
             dbfile,
-            inbox: Arc::new(RwLock::new(Imap::new())),
+            inbox,
+            inbox_watch,
             cb,
             os_name: Some(os_name),
             running_state: Arc::new(RwLock::new(Default::default())),
@@ -132,12 +138,10 @@ impl Context {
             sentbox_thread: Arc::new(RwLock::new(JobThread::new(
                 "SENTBOX",
                 "configured_sentbox_folder",
-                Imap::new(),
             ))),
             mvbox_thread: Arc::new(RwLock::new(JobThread::new(
                 "MVBOX",
                 "configured_mvbox_folder",
-                Imap::new(),
             ))),
             probe_imap_network: Arc::new(RwLock::new(false)),
             perform_inbox_jobs_needed: Arc::new(RwLock::new(false)),
@@ -454,19 +458,28 @@ impl Context {
             }
         }
     }
+
+    pub fn interrupt_inbox_idle(&self) {
+        let &(ref lock, ref cvar) = &*self.inbox_watch.clone();
+        let mut watch = lock.lock().unwrap();
+
+        *watch = true;
+        cvar.notify_one();
+    }
 }
 
 impl Drop for Context {
     fn drop(&mut self) {
         info!(self, "disconnecting INBOX-watch",);
-        self.inbox.read().unwrap().disconnect(self);
+        self.inbox.write().unwrap().disconnect(self);
         info!(self, "disconnecting sentbox-thread",);
-        self.sentbox_thread.read().unwrap().imap.disconnect(self);
+        self.sentbox_thread.write().unwrap().imap.disconnect(self);
         info!(self, "disconnecting mvbox-thread",);
-        self.mvbox_thread.read().unwrap().imap.disconnect(self);
+        self.mvbox_thread.write().unwrap().imap.disconnect(self);
         info!(self, "disconnecting SMTP");
         self.smtp.clone().lock().unwrap().disconnect();
         self.sql.close(self);
+        info!(self, "Context closed");
     }
 }
 

src/dc_tools.rs

@@ -154,15 +154,13 @@ pub(crate) fn dc_timestamp_from_date(date_time: *mut mailimf_date_time) -> i64 {
  ******************************************************************************/
 
 pub fn dc_timestamp_to_str(wanted: i64) -> String {
-    let ts = Local.timestamp(wanted, 0);
+    let ts = chrono::Utc.timestamp(wanted, 0);
     ts.format("%Y.%m.%d %H:%M:%S").to_string()
 }
 
 pub(crate) fn dc_gm2local_offset() -> i64 {
-    /* returns the offset that must be _added_ to an UTC/GMT-time to create the localtime.
-    the function may return negative values. */
     let lt = Local::now();
-    lt.offset().local_minus_utc() as i64
+    ((lt.offset().local_minus_utc() / (60 * 60)) * 100) as i64
 }
 
 /* timesmearing */

src/e2ee.rs

@@ -498,7 +498,7 @@ fn decrypt_if_autocrypt_message(
     public_keyring_for_validate: &Keyring,
     ret_valid_signatures: &mut HashSet<String>,
     ret_gossip_headers: *mut *mut mailimf_fields,
-) -> Result<bool> {
+) -> Result<(bool)> {
     /* The returned bool is true if we detected an Autocrypt-encrypted
     message and successfully decrypted it. Decryption then modifies the
     passed in mime structure in place. The returned bool is false

src/imap_client.rs

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

src/job.rs

@@ -219,7 +219,7 @@ impl Job {
 
     #[allow(non_snake_case)]
     fn do_DC_JOB_MOVE_MSG(&mut self, context: &Context) {
-        let inbox = context.inbox.read().unwrap();
+        let mut inbox = context.inbox.write().unwrap();
 
         if let Ok(msg) = Message::load_from_db(context, MsgId::new(self.foreign_id)) {
             if context
@@ -245,10 +245,10 @@ impl Job {
                     &dest_folder,
                     &mut dest_uid,
                 ) {
-                    ImapActionResult::RetryLater => {
+                    ImapResult::RetryLater => {
                         self.try_again_later(3i32, None);
                     }
-                    ImapActionResult::Success => {
+                    ImapResult::Success => {
                         message::update_server_uid(
                             context,
                             &msg.rfc724_mid,
@@ -256,7 +256,7 @@ impl Job {
                             dest_uid,
                         );
                     }
-                    ImapActionResult::Failed | ImapActionResult::AlreadyDone => {}
+                    ImapResult::Failed | ImapResult::AlreadyDone => {}
                 }
             }
         }
@@ -264,7 +264,7 @@ impl Job {
 
     #[allow(non_snake_case)]
     fn do_DC_JOB_DELETE_MSG_ON_IMAP(&mut self, context: &Context) {
-        let inbox = context.inbox.read().unwrap();
+        let mut inbox = context.inbox.write().unwrap();
 
         if let Ok(mut msg) = Message::load_from_db(context, MsgId::new(self.foreign_id)) {
             if !msg.rfc724_mid.is_empty() {
@@ -280,7 +280,7 @@ impl Job {
                     let mid = msg.rfc724_mid;
                     let server_folder = msg.server_folder.as_ref().unwrap();
                     let res = inbox.delete_msg(context, &mid, server_folder, &mut msg.server_uid);
-                    if res == ImapActionResult::RetryLater {
+                    if res == ImapResult::RetryLater {
                         self.try_again_later(-1i32, None);
                         return;
                     }
@@ -292,7 +292,7 @@ impl Job {
 
     #[allow(non_snake_case)]
     fn do_DC_JOB_EMPTY_SERVER(&mut self, context: &Context) {
-        let inbox = context.inbox.read().unwrap();
+        let mut inbox = context.inbox.write().unwrap();
         if self.foreign_id & DC_EMPTY_MVBOX > 0 {
             if let Some(mvbox_folder) = context
                 .sql
@@ -308,16 +308,16 @@ impl Job {
 
     #[allow(non_snake_case)]
     fn do_DC_JOB_MARKSEEN_MSG_ON_IMAP(&mut self, context: &Context) {
-        let inbox = context.inbox.read().unwrap();
+        let mut inbox = context.inbox.write().unwrap();
 
         if let Ok(msg) = Message::load_from_db(context, MsgId::new(self.foreign_id)) {
             let folder = msg.server_folder.as_ref().unwrap();
             match inbox.set_seen(context, folder, msg.server_uid) {
-                ImapActionResult::RetryLater => {
+                ImapResult::RetryLater => {
                     self.try_again_later(3i32, None);
                 }
-                ImapActionResult::AlreadyDone => {}
-                ImapActionResult::Success | ImapActionResult::Failed => {
+                ImapResult::AlreadyDone => {}
+                ImapResult::Success | ImapResult::Failed => {
                     // XXX the message might just have been moved
                     // we want to send out an MDN anyway
                     // The job will not be retried so locally
@@ -342,8 +342,8 @@ impl Job {
             .unwrap_or_default()
             .to_string();
         let uid = self.param.get_int(Param::ServerUid).unwrap_or_default() as u32;
-        let inbox = context.inbox.read().unwrap();
-        if inbox.set_seen(context, &folder, uid) == ImapActionResult::RetryLater {
+        let mut inbox = context.inbox.write().unwrap();
+        if inbox.set_seen(context, &folder, uid) == ImapResult::RetryLater {
             self.try_again_later(3i32, None);
             return;
         }
@@ -361,7 +361,7 @@ impl Job {
                 .get_raw_config(context, "configured_mvbox_folder");
             if let Some(dest_folder) = dest_folder {
                 let mut dest_uid = 0;
-                if ImapActionResult::RetryLater
+                if ImapResult::RetryLater
                     == inbox.mv(context, &folder, uid, &dest_folder, &mut dest_uid)
                 {
                     self.try_again_later(3, None);
@@ -383,10 +383,10 @@ pub fn job_kill_action(context: &Context, action: Action) -> bool {
 }
 
 pub fn perform_imap_fetch(context: &Context) {
-    let inbox = context.inbox.read().unwrap();
+    let mut inbox = context.inbox.write().unwrap();
     let start = std::time::Instant::now();
 
-    if 0 == connect_to_inbox(context, &inbox) {
+    if 0 == connect_to_inbox(context, &mut inbox) {
         return;
     }
     if !context.get_config_bool(Config::InboxWatch) {
@@ -407,9 +407,9 @@ pub fn perform_imap_fetch(context: &Context) {
 }
 
 pub fn perform_imap_idle(context: &Context) {
-    let inbox = context.inbox.read().unwrap();
+    let mut inbox = context.inbox.write().unwrap();
 
-    connect_to_inbox(context, &inbox);
+    connect_to_inbox(context, &mut inbox);
 
     if *context.perform_inbox_jobs_needed.clone().read().unwrap() {
         info!(
@@ -418,8 +418,11 @@ pub fn perform_imap_idle(context: &Context) {
         );
         return;
     }
+    drop(inbox);
     info!(context, "INBOX-IDLE started...");
-    inbox.idle(context);
+
+    context.inbox.write().unwrap().idle(context);
+
     info!(context, "INBOX-IDLE ended.");
 }
 
@@ -438,7 +441,7 @@ pub fn perform_mvbox_idle(context: &Context) {
 
     context
         .mvbox_thread
-        .read()
+        .write()
         .unwrap()
         .idle(context, use_network);
 }
@@ -462,7 +465,7 @@ pub fn perform_sentbox_idle(context: &Context) {
 
     context
         .sentbox_thread
-        .read()
+        .write()
         .unwrap()
         .idle(context, use_network);
 }
@@ -926,7 +929,7 @@ fn suspend_smtp_thread(context: &Context, suspend: bool) {
     }
 }
 
-pub fn connect_to_inbox(context: &Context, inbox: &Imap) -> libc::c_int {
+pub fn connect_to_inbox(context: &Context, inbox: &mut Imap) -> libc::c_int {
     let ret_connected = dc_connect_to_configured_imap(context, inbox);
     if 0 != ret_connected {
         inbox.set_watch_folder("INBOX".into());
@@ -980,6 +983,24 @@ pub fn job_add(
     foreign_id: libc::c_int,
     param: Params,
     delay_seconds: i64,
+) {
+    job_add_no_interrupt(context, action, foreign_id, param, delay_seconds);
+
+    let thread: Thread = action.into();
+
+    match thread {
+        Thread::Imap => interrupt_imap_idle(context),
+        Thread::Smtp => interrupt_smtp_idle(context),
+        Thread::Unknown => {}
+    }
+}
+
+pub fn job_add_no_interrupt(
+    context: &Context,
+    action: Action,
+    foreign_id: libc::c_int,
+    param: Params,
+    delay_seconds: i64,
 ) {
     if action == Action::Unknown {
         error!(context, "Invalid action passed to job_add");
@@ -1002,29 +1023,30 @@ pub fn job_add(
             (timestamp + delay_seconds as i64)
         ]
     ).ok();
-
-    match thread {
-        Thread::Imap => interrupt_imap_idle(context),
-        Thread::Smtp => interrupt_smtp_idle(context),
-        Thread::Unknown => {}
-    }
 }
 
 pub fn interrupt_smtp_idle(context: &Context) {
     info!(context, "Interrupting SMTP-idle...",);
 
     let &(ref lock, ref cvar) = &*context.smtp_state.clone();
-    let mut state = lock.lock().unwrap();
+    {
+        let mut state = lock.lock().unwrap();
 
-    state.perform_jobs_needed = 1;
-    state.idle = true;
+        state.perform_jobs_needed = 1;
+        state.idle = true;
+        info!(context, "smtp interrupt jobs written");
+    }
     cvar.notify_one();
+    info!(context, "smtp interrupt done");
 }
 
 pub fn interrupt_imap_idle(context: &Context) {
     info!(context, "Interrupting INBOX-IDLE...",);
 
     *context.perform_inbox_jobs_needed.write().unwrap() = true;
+    info!(context, "interrupt jobs written");
 
-    context.inbox.read().unwrap().interrupt_idle();
+    context.interrupt_inbox_idle();
+
+    info!(context, "interrupt imap done");
 }

src/job_thread.rs

@@ -9,6 +9,7 @@ pub struct JobThread {
     pub name: &'static str,
     pub folder_config_name: &'static str,
     pub imap: Imap,
+    watch: Arc<(Mutex<bool>, Condvar)>,
     pub state: Arc<(Mutex<JobState>, Condvar)>,
 }
 
@@ -21,11 +22,15 @@ pub struct JobState {
 }
 
 impl JobThread {
-    pub fn new(name: &'static str, folder_config_name: &'static str, imap: Imap) -> Self {
+    pub fn new(name: &'static str, folder_config_name: &'static str) -> Self {
+        let watch = Arc::new((Mutex::new(false), Condvar::new()));
+        let imap = Imap::new(watch.clone());
+
         JobThread {
             name,
             folder_config_name,
             imap,
+            watch,
             state: Arc::new((Mutex::new(Default::default()), Condvar::new())),
         }
     }
@@ -63,13 +68,22 @@ impl JobThread {
 
         info!(context, "Interrupting {}-IDLE...", self.name);
 
-        self.imap.interrupt_idle();
+        // interrupt imap idle
+        let &(ref lock, ref cvar) = &*self.watch.clone();
+        {
+            let mut watch = lock.lock().unwrap();
+
+            *watch = true;
+            cvar.notify_one();
+        }
 
         let &(ref lock, ref cvar) = &*self.state.clone();
-        let mut state = lock.lock().unwrap();
-
-        state.idle = true;
+        {
+            let mut state = lock.lock().unwrap();
+            state.idle = true;
+        }
         cvar.notify_one();
+        info!(context, "{}-idle interrupt done", self.name);
     }
 
     pub fn fetch(&mut self, context: &Context, use_network: bool) {
@@ -106,18 +120,13 @@ impl JobThread {
         self.state.0.lock().unwrap().using_handle = false;
     }
 
-    fn connect_to_imap(&self, context: &Context) -> bool {
-        if async_std::task::block_on(async move { self.imap.is_connected().await }) {
+    fn connect_to_imap(&mut self, context: &Context) -> bool {
+        if self.imap.is_connected() {
             return true;
         }
-        let watch_folder_name = match context.sql.get_raw_config(context, self.folder_config_name) {
-            Some(name) => name,
-            None => {
-                return false;
-            }
-        };
 
-        let ret_connected = dc_connect_to_configured_imap(context, &self.imap) != 0;
+        let mut ret_connected = dc_connect_to_configured_imap(context, &mut self.imap) != 0;
+
         if ret_connected {
             if context
                 .sql
@@ -128,13 +137,18 @@ impl JobThread {
                 self.imap.configure_folders(context, 0x1);
             }
 
-            self.imap.set_watch_folder(watch_folder_name);
+            if let Some(mvbox_name) = context.sql.get_raw_config(context, self.folder_config_name) {
+                self.imap.set_watch_folder(mvbox_name);
+            } else {
+                self.imap.disconnect(context);
+                ret_connected = false;
+            }
         }
 
         ret_connected
     }
 
-    pub fn idle(&self, context: &Context, use_network: bool) {
+    pub fn idle(&mut self, context: &Context, use_network: bool) {
         {
             let &(ref lock, ref cvar) = &*self.state.clone();
             let mut state = lock.lock().unwrap();
@@ -170,18 +184,10 @@ impl JobThread {
             }
         }
 
-        if self.connect_to_imap(context) {
-            info!(context, "{}-IDLE started...", self.name,);
-            self.imap.idle(context);
-            info!(context, "{}-IDLE ended.", self.name);
-        } else {
-            // It's probably wrong that the thread even runs
-            // but let's call fake_idle and tell it to not try network at all.
-            // (once we move to rust-managed threads this problem goes away)
-            info!(context, "{}-IDLE not connected, fake-idling", self.name);
-            async_std::task::block_on(async move { self.imap.fake_idle(context, false).await });
-            info!(context, "{}-IDLE fake-idling finished", self.name);
-        }
+        self.connect_to_imap(context);
+        info!(context, "{}-IDLE started...", self.name,);
+        self.imap.idle(context);
+        info!(context, "{}-IDLE ended.", self.name);
 
         self.state.0.lock().unwrap().using_handle = false;
     }

src/key.rs

@@ -29,44 +29,44 @@ impl From<SignedSecretKey> for Key {
     }
 }
 
-impl std::convert::TryFrom<Key> for SignedSecretKey {
+impl std::convert::TryInto<SignedSecretKey> for Key {
     type Error = ();
 
-    fn try_from(value: Key) -> Result<Self, Self::Error> {
-        match value {
+    fn try_into(self) -> Result<SignedSecretKey, Self::Error> {
+        match self {
             Key::Public(_) => Err(()),
             Key::Secret(key) => Ok(key),
         }
     }
 }
 
-impl<'a> std::convert::TryFrom<&'a Key> for &'a SignedSecretKey {
+impl<'a> std::convert::TryInto<&'a SignedSecretKey> for &'a Key {
     type Error = ();
 
-    fn try_from(value: &'a Key) -> Result<Self, Self::Error> {
-        match value {
+    fn try_into(self) -> Result<&'a SignedSecretKey, Self::Error> {
+        match self {
             Key::Public(_) => Err(()),
             Key::Secret(key) => Ok(key),
         }
     }
 }
 
-impl std::convert::TryFrom<Key> for SignedPublicKey {
+impl std::convert::TryInto<SignedPublicKey> for Key {
     type Error = ();
 
-    fn try_from(value: Key) -> Result<Self, Self::Error> {
-        match value {
+    fn try_into(self) -> Result<SignedPublicKey, Self::Error> {
+        match self {
             Key::Public(key) => Ok(key),
             Key::Secret(_) => Err(()),
         }
     }
 }
 
-impl<'a> std::convert::TryFrom<&'a Key> for &'a SignedPublicKey {
+impl<'a> std::convert::TryInto<&'a SignedPublicKey> for &'a Key {
     type Error = ();
 
-    fn try_from(value: &'a Key) -> Result<Self, Self::Error> {
-        match value {
+    fn try_into(self) -> Result<&'a SignedPublicKey, Self::Error> {
+        match self {
             Key::Public(key) => Ok(key),
             Key::Secret(_) => Err(()),
         }

src/lib.rs

@@ -40,7 +40,6 @@ pub mod contact;
 pub mod context;
 mod e2ee;
 mod imap;
-mod imap_client;
 pub mod imex;
 pub mod job;
 mod job_thread;

src/login_param.rs

@@ -3,10 +3,6 @@ use std::fmt;
 
 use crate::context::Context;
 use crate::error::Error;
-use async_std::sync::Arc;
-use rustls;
-use webpki;
-use webpki_roots;
 
 #[derive(Copy, Clone, Debug, Display, FromPrimitive)]
 #[repr(i32)]
@@ -255,49 +251,27 @@ fn get_readable_flags(flags: i32) -> String {
     res
 }
 
-pub struct NoCertificateVerification {}
-
-impl rustls::ServerCertVerifier for NoCertificateVerification {
-    fn verify_server_cert(
-        &self,
-        _roots: &rustls::RootCertStore,
-        _presented_certs: &[rustls::Certificate],
-        _dns_name: webpki::DNSNameRef<'_>,
-        _ocsp: &[u8],
-    ) -> Result<rustls::ServerCertVerified, rustls::TLSError> {
-        Ok(rustls::ServerCertVerified::assertion())
-    }
-}
-
-pub fn dc_build_tls_config(certificate_checks: CertificateChecks) -> rustls::ClientConfig {
-    let mut config = rustls::ClientConfig::new();
-    config
-        .root_store
-        .add_server_trust_anchors(&webpki_roots::TLS_SERVER_ROOTS);
-
+pub fn dc_build_tls(
+    certificate_checks: CertificateChecks,
+) -> Result<native_tls::TlsConnector, native_tls::Error> {
+    let mut tls_builder = native_tls::TlsConnector::builder();
     match certificate_checks {
-        CertificateChecks::Strict => {}
         CertificateChecks::Automatic => {
             // Same as AcceptInvalidCertificates for now.
             // TODO: use provider database when it becomes available
-            config
-                .dangerous()
-                .set_certificate_verifier(Arc::new(NoCertificateVerification {}));
-        }
-        CertificateChecks::AcceptInvalidCertificates => {
-            // TODO: only accept invalid certs
-            config
-                .dangerous()
-                .set_certificate_verifier(Arc::new(NoCertificateVerification {}));
+            tls_builder
+                .danger_accept_invalid_hostnames(true)
+                .danger_accept_invalid_certs(true)
         }
+        CertificateChecks::Strict => &mut tls_builder,
         CertificateChecks::AcceptInvalidHostnames => {
-            // TODO: only accept invalid hostnames
-            config
-                .dangerous()
-                .set_certificate_verifier(Arc::new(NoCertificateVerification {}));
+            tls_builder.danger_accept_invalid_hostnames(true)
         }
+        CertificateChecks::AcceptInvalidCertificates => tls_builder
+            .danger_accept_invalid_hostnames(true)
+            .danger_accept_invalid_certs(true),
     }
-    config
+    .build()
 }
 
 #[cfg(test)]

src/pgp.rs

@@ -5,7 +5,7 @@ use std::io::Cursor;
 use pgp::armor::BlockType;
 use pgp::composed::{
     Deserializable, KeyType as PgpKeyType, Message, SecretKeyParamsBuilder, SignedPublicKey,
-    SignedPublicSubKey, SignedSecretKey, SubkeyParamsBuilder,
+    SignedSecretKey, SubkeyParamsBuilder,
 };
 use pgp::crypto::{HashAlgorithm, SymmetricKeyAlgorithm};
 use pgp::types::{CompressionAlgorithm, KeyTrait, SecretKeyTrait, StringToKey};
@@ -97,29 +97,18 @@ pub fn create_keypair(addr: impl AsRef<str>) -> Option<(Key, Key)> {
     Some((Key::Public(public_key), Key::Secret(private_key)))
 }
 
-/// Select subkey of the public key to use for encryption.
-///
-/// Currently the first subkey is selected.
-fn select_pk_for_encryption(key: &SignedPublicKey) -> Option<&SignedPublicSubKey> {
-    key.public_subkeys.iter().find(|_k|
-        // TODO: check if it is an encryption subkey
-        true)
-}
-
 pub fn pk_encrypt(
     plain: &[u8],
     public_keys_for_encryption: &Keyring,
     private_key_for_signing: Option<&Key>,
 ) -> Result<String, Error> {
     let lit_msg = Message::new_literal_bytes("", plain);
-    let pkeys: Vec<&SignedPublicSubKey> = public_keys_for_encryption
+    let pkeys: Vec<&SignedPublicKey> = public_keys_for_encryption
         .keys()
         .iter()
         .filter_map(|key| {
-            key.as_ref()
-                .try_into()
-                .ok()
-                .and_then(select_pk_for_encryption)
+            let k: &Key = &key;
+            k.try_into().ok()
         })
         .collect();
 

src/smtp.rs

@@ -5,7 +5,7 @@ use crate::constants::*;
 use crate::context::Context;
 use crate::error::Error;
 use crate::events::Event;
-use crate::login_param::{dc_build_tls_config, LoginParam};
+use crate::login_param::{dc_build_tls, LoginParam};
 use crate::oauth2::*;
 
 #[derive(DebugStub)]
@@ -65,8 +65,8 @@ impl Smtp {
         let domain = &lp.send_server;
         let port = lp.send_port as u16;
 
-        let tls_config = dc_build_tls_config(lp.smtp_certificate_checks);
-        let tls_parameters = ClientTlsParameters::new(domain.to_string(), tls_config);
+        let tls = dc_build_tls(lp.smtp_certificate_checks).unwrap();
+        let tls_parameters = ClientTlsParameters::new(domain.to_string(), tls);
 
         let (creds, mechanism) = if 0 != lp.server_flags & (DC_LP_AUTH_OAUTH2 as i32) {
             // oauth2