try fix upload

Cargo.lock

@@ -479,7 +479,7 @@ dependencies = [
  "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "lettre 0.9.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)",
- "mmime 0.1.2-alpha.0 (git+https://github.com/dignifiedquire/mmime?rev=bccd2c2)",
+ "mmime 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "native-tls 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "num-derive 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "num-traits 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1192,8 +1192,8 @@ dependencies = [
 
 [[package]]
 name = "mmime"
-version = "0.1.2-alpha.0"
-source = "git+https://github.com/dignifiedquire/mmime?rev=bccd2c2#bccd2c2c89e9241e05f321c963f638affdccad96"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "charset 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "chrono 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -2884,7 +2884,7 @@ dependencies = [
 "checksum miniz_oxide 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7108aff85b876d06f22503dcce091e29f76733b2bfdd91eebce81f5e68203a10"
 "checksum mio 0.6.19 (registry+https://github.com/rust-lang/crates.io-index)" = "83f51996a3ed004ef184e16818edc51fadffe8e7ca68be67f9dee67d84d0ff23"
 "checksum miow 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "8c1f2f3b1cf331de6896aabf6e9d55dca90356cc9960cca7eaaf408a355ae919"
-"checksum mmime 0.1.2-alpha.0 (git+https://github.com/dignifiedquire/mmime?rev=bccd2c2)" = "<none>"
+"checksum mmime 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a1246fa340840c36f1fca1507db82463fbc4c2f7763fe84bfde666c7381e0593"
 "checksum native-tls 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "4b2df1a4c22fd44a62147fd8f13dd0f95c9d8ca7b2610299b2a2f9cf8964274e"
 "checksum net2 0.2.33 (registry+https://github.com/rust-lang/crates.io-index)" = "42550d9fb7b6684a6d404d9fa7250c2eb2646df731d1c06afc06dcee9e1bcf88"
 "checksum nix 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4dbdc256eaac2e3bd236d93ad999d3479ef775c863dbda3068c4006a92eec51b"

Cargo.toml

@@ -24,7 +24,7 @@ num-traits = "0.2.6"
 native-tls = "0.2.3"
 lettre = "0.9.0"
 imap = "1.0.1"
-mmime = { git = "https://github.com/dignifiedquire/mmime", rev = "bccd2c2" }
+mmime = "0.1.0"
 base64 = "0.10"
 charset = "0.1"
 percent-encoding = "2.0"

ci_scripts/ci_upload.sh

@@ -34,6 +34,7 @@ echo -----------------------
 # Bundle external shared libraries into the wheels
 pushd $WHEELHOUSEDIR
 
+pip3 install -U setuptools 
 pip3 install devpi-client
 devpi use https://m.devpi.net
 devpi login dc --password $DEVPI_LOGIN

ci_scripts/run_all.sh

@@ -41,7 +41,7 @@ if [ -n "$TESTS" ]; then
     # see https://github.com/deltachat/deltachat-core-rust/issues/331
     # unset DCC_PY_LIVECONFIG
 
-    tox --workdir "$TOXWORKDIR" -e lint,py35,py36,py37,auditwheels
+    tox --workdir "$TOXWORKDIR" -e lint,py27,py35,py36,py37,auditwheels
     popd
 fi
 

python/tox.ini

@@ -1,6 +1,7 @@
 [tox]
 # make sure to update environment list in travis.yml and appveyor.yml
 envlist =
+    py27
     py35
     lint
     auditwheels

src/config.rs

@@ -33,7 +33,6 @@ pub enum Config {
     E2eeEnabled,
     #[strum(props(default = "1"))]
     MdnsEnabled,
-    #[strum(props(default = "1"))]
     InboxWatch,
     #[strum(props(default = "1"))]
     SentboxWatch,

src/configure/mod.rs

@@ -2,9 +2,9 @@ use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
 
 use crate::constants::Event;
 use crate::context::Context;
+use crate::dc_e2ee::*;
 use crate::dc_loginparam::*;
 use crate::dc_tools::*;
-use crate::e2ee;
 use crate::imap::*;
 use crate::job::*;
 use crate::oauth2::*;
@@ -589,7 +589,7 @@ pub unsafe fn dc_job_do_DC_JOB_CONFIGURE_IMAP(context: &Context, _job: &Job) {
                                                             .ok();
                                                         if !s.shall_stop_ongoing {
                                                             progress!(context, 920);
-                                                            e2ee::ensure_secret_key_exists(context);
+                                                            dc_ensure_secret_key_exists(context);
                                                             success = true;
                                                             info!(
                                                                 context,

src/contact.rs

@@ -7,9 +7,9 @@ use crate::aheader::EncryptPreference;
 use crate::config::Config;
 use crate::constants::*;
 use crate::context::Context;
+use crate::dc_e2ee::*;
 use crate::dc_loginparam::*;
 use crate::dc_tools::*;
-use crate::e2ee;
 use crate::error::Result;
 use crate::key::*;
 use crate::message::MessageState;
@@ -603,7 +603,7 @@ impl<'a> Contact<'a> {
                     });
                 ret += &p;
                 if self_key.is_none() {
-                    e2ee::ensure_secret_key_exists(context)?;
+                    dc_ensure_secret_key_exists(context)?;
                     self_key = Key::from_self_public(context, &loginparam.addr, &context.sql);
                 }
                 let p = context.stock_str(StockMessage::FingerPrints);

src/context.rs

@@ -4,6 +4,7 @@ use crate::chat::*;
 use crate::constants::*;
 use crate::contact::*;
 use crate::dc_loginparam::*;
+use crate::dc_move::*;
 use crate::dc_receive_imf::*;
 use crate::dc_tools::*;
 use crate::imap::*;
@@ -227,7 +228,7 @@ unsafe fn cb_precheck_imf(
         if as_str(old_server_folder) != server_folder || old_server_uid != server_uid {
             dc_update_server_uid(context, rfc724_mid, server_folder, server_uid);
         }
-        do_heuristics_moves(context, server_folder, msg_id);
+        dc_do_heuristics_moves(context, server_folder, msg_id);
         if 0 != mark_seen {
             job_add(
                 context,
@@ -574,45 +575,6 @@ pub fn dc_is_mvbox(context: &Context, folder_name: impl AsRef<str>) -> bool {
     }
 }
 
-pub fn do_heuristics_moves(context: &Context, folder: &str, msg_id: u32) {
-    if context
-        .sql
-        .get_config_int(context, "mvbox_move")
-        .unwrap_or_else(|| 1)
-        == 0
-    {
-        return;
-    }
-
-    if !dc_is_inbox(context, folder) && !dc_is_sentbox(context, folder) {
-        return;
-    }
-
-    if let Ok(msg) = dc_msg_new_load(context, msg_id) {
-        if dc_msg_is_setupmessage(&msg) {
-            // do not move setup messages;
-            // there may be a non-delta device that wants to handle it
-            return;
-        }
-
-        if dc_is_mvbox(context, folder) {
-            dc_update_msg_move_state(context, msg.rfc724_mid, MoveState::Stay);
-        }
-
-        // 1 = dc message, 2 = reply to dc message
-        if 0 != msg.is_dc_message {
-            job_add(
-                context,
-                Action::MoveMsg,
-                msg.id as libc::c_int,
-                Params::new(),
-                0,
-            );
-            dc_update_msg_move_state(context, msg.rfc724_mid, MoveState::Moving);
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/dc_imex.rs

@@ -11,8 +11,8 @@ use crate::config::Config;
 use crate::configure::*;
 use crate::constants::*;
 use crate::context::Context;
+use crate::dc_e2ee::*;
 use crate::dc_tools::*;
-use crate::e2ee;
 use crate::error::*;
 use crate::job::*;
 use crate::key::*;
@@ -196,7 +196,7 @@ pub fn dc_render_setup_file(context: &Context, passphrase: &str) -> Result<Strin
         passphrase.len() >= 2,
         "Passphrase must be at least 2 chars long."
     );
-    let self_addr = e2ee::ensure_secret_key_exists(context)?;
+    let self_addr = dc_ensure_secret_key_exists(context)?;
     let private_key = Key::from_self_private(context, self_addr, &context.sql)
         .ok_or(format_err!("Failed to get private key."))?;
     let ac_headers = match context
@@ -522,7 +522,7 @@ pub unsafe fn dc_job_do_DC_JOB_IMEX_IMAP(context: &Context, job: &Job) {
             } else {
                 if what == 1 || what == 11 {
                     /* before we export anything, make sure the private key exists */
-                    if e2ee::ensure_secret_key_exists(context).is_err() {
+                    if dc_ensure_secret_key_exists(context).is_err() {
                         error!(
                             context,
                             0,
@@ -712,7 +712,7 @@ The macro avoids weird values of 0% or 100% while still working. */
 // TODO should return bool /rtn
 #[allow(non_snake_case)]
 unsafe fn export_backup(context: &Context, dir: *const libc::c_char) -> libc::c_int {
-    let mut ok_to_continue: bool;
+    let mut current_block: u64;
     let mut success: libc::c_int = 0;
 
     let mut delete_dest_file: libc::c_int = 0;
@@ -768,30 +768,32 @@ unsafe fn export_backup(context: &Context, dir: *const libc::c_char) -> libc::c_
                 .is_err()
                 {
                     /* error already logged */
-                    ok_to_continue = false;
+                    current_block = 11487273724841241105;
                 } else {
-                    ok_to_continue = true;
+                    current_block = 14648156034262866959;
                 }
             } else {
-                ok_to_continue = true;
+                current_block = 14648156034262866959;
             }
-            if ok_to_continue {
-                let mut total_files_cnt = 0;
-                let dir = std::path::Path::new(as_str(context.get_blobdir()));
-                if let Ok(dir_handle) = std::fs::read_dir(dir) {
-                    total_files_cnt += dir_handle.filter(|r| r.is_ok()).count();
+            match current_block {
+                11487273724841241105 => {}
+                _ => {
+                    let mut total_files_cnt = 0;
+                    let dir = std::path::Path::new(as_str(context.get_blobdir()));
+                    if let Ok(dir_handle) = std::fs::read_dir(dir) {
+                        total_files_cnt += dir_handle.filter(|r| r.is_ok()).count();
 
-                    info!(context, 0, "EXPORT: total_files_cnt={}", total_files_cnt);
-                    if total_files_cnt > 0 {
-                        // scan directory, pass 2: copy files
-                        if let Ok(dir_handle) = std::fs::read_dir(dir) {
-                            sql.prepare(
+                        info!(context, 0, "EXPORT: total_files_cnt={}", total_files_cnt);
+                        if total_files_cnt > 0 {
+                            // scan directory, pass 2: copy files
+                            if let Ok(dir_handle) = std::fs::read_dir(dir) {
+                                sql.prepare(
                                     "INSERT INTO backup_blobs (file_name, file_content) VALUES (?, ?);",
                                     move |mut stmt, _| {
                                         let mut processed_files_cnt = 0;
                                         for entry in dir_handle {
                                             if entry.is_err() {
-                                                ok_to_continue = true;
+                                                current_block = 2631791190359682872;
                                                 break;
                                             }
                                             let entry = entry.unwrap();
@@ -803,7 +805,7 @@ unsafe fn export_backup(context: &Context, dir: *const libc::c_char) -> libc::c_
                                                 .shall_stop_ongoing
                                             {
                                                 delete_dest_file = 1;
-                                                ok_to_continue = false;
+                                                current_block = 11487273724841241105;
                                                 break;
                                             } else {
                                                 processed_files_cnt += 1;
@@ -848,7 +850,7 @@ unsafe fn export_backup(context: &Context, dir: *const libc::c_char) -> libc::c_
                                                                 &curr_pathNfilename,
                                                             );
                                                             /* this is not recoverable! writing to the sqlite database should work! */
-                                                            ok_to_continue = false;
+                                                            current_block = 11487273724841241105;
                                                             break;
                                                         }
                                                     } else {
@@ -860,39 +862,43 @@ unsafe fn export_backup(context: &Context, dir: *const libc::c_char) -> libc::c_
                                         Ok(())
                                     }
                                 ).unwrap();
+                            } else {
+                                error!(
+                                    context,
+                                    0,
+                                    "Backup: Cannot copy from blob-directory \"{}\".",
+                                    as_str(context.get_blobdir()),
+                                );
+                            }
                         } else {
-                            error!(
-                                context,
-                                0,
-                                "Backup: Cannot copy from blob-directory \"{}\".",
-                                as_str(context.get_blobdir()),
-                            );
+                            info!(context, 0, "Backup: No files to copy.",);
+                            current_block = 2631791190359682872;
+                        }
+                        match current_block {
+                            11487273724841241105 => {}
+                            _ => {
+                                if sql
+                                    .set_config_int(context, "backup_time", now as i32)
+                                    .is_ok()
+                                {
+                                    context.call_cb(
+                                        Event::IMEX_FILE_WRITTEN,
+                                        dest_pathNfilename as uintptr_t,
+                                        0,
+                                    );
+                                    success = 1;
+                                }
+                            }
                         }
                     } else {
-                        info!(context, 0, "Backup: No files to copy.",);
-                        ok_to_continue = true;
-                    }
-                    if ok_to_continue {
-                        if sql
-                            .set_config_int(context, "backup_time", now as i32)
-                            .is_ok()
-                        {
-                            context.call_cb(
-                                Event::IMEX_FILE_WRITTEN,
-                                dest_pathNfilename as uintptr_t,
-                                0,
-                            );
-                            success = 1;
-                        }
-                    }
-                } else {
-                    error!(
-                        context,
-                        0,
-                        "Backup: Cannot get info for blob-directory \"{}\".",
-                        as_str(context.get_blobdir())
-                    );
-                };
+                        error!(
+                            context,
+                            0,
+                            "Backup: Cannot get info for blob-directory \"{}\".",
+                            as_str(context.get_blobdir())
+                        );
+                    };
+                }
             }
         }
     }

src/dc_mimefactory.rs

@@ -15,9 +15,9 @@ use crate::chat::{self, Chat};
 use crate::constants::*;
 use crate::contact::*;
 use crate::context::{dc_get_version_str, Context};
+use crate::dc_e2ee::*;
 use crate::dc_strencode::*;
 use crate::dc_tools::*;
-use crate::e2ee::*;
 use crate::error::Error;
 use crate::location;
 use crate::message::*;
@@ -353,7 +353,13 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
     let mut force_plaintext: libc::c_int = 0;
     let mut do_gossip: libc::c_int = 0;
     let mut grpimage = None;
-    let mut e2ee_helper = E2eeHelper::default();
+    let mut e2ee_helper = dc_e2ee_helper_t {
+        encryption_successfull: 0,
+        cdata_to_free: ptr::null_mut(),
+        encrypted: 0,
+        signatures: Default::default(),
+        gossipped_addr: Default::default(),
+    };
 
     if factory.loaded as libc::c_uint == DC_MF_NOTHING_LOADED as libc::c_int as libc::c_uint
         || !factory.out.is_null()
@@ -1027,7 +1033,7 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
                 ),
             );
             if force_plaintext != 2 {
-                e2ee_helper.encrypt(
+                dc_e2ee_encrypt(
                     factory.context,
                     factory.recipients_addr,
                     force_plaintext,
@@ -1035,9 +1041,10 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
                     min_verified,
                     do_gossip,
                     message,
+                    &mut e2ee_helper,
                 );
             }
-            if e2ee_helper.encryption_successfull {
+            if 0 != e2ee_helper.encryption_successfull {
                 factory.out_encrypted = 1;
                 if 0 != do_gossip {
                     factory.out_gossiped = 1
@@ -1045,14 +1052,14 @@ pub unsafe fn dc_mimefactory_render(factory: &mut dc_mimefactory_t) -> libc::c_i
             }
             factory.out = mmap_string_new(b"\x00" as *const u8 as *const libc::c_char);
             mailmime_write_mem(factory.out, &mut col, message);
-            success = 1;
+            success = 1
         }
     }
 
     if !message.is_null() {
         mailmime_free(message);
     }
-    e2ee_helper.thanks();
+    dc_e2ee_thanks(&mut e2ee_helper);
     free(message_text as *mut libc::c_void);
     free(message_text2 as *mut libc::c_void);
     free(subject_str as *mut libc::c_void);

src/dc_mimeparser.rs

@@ -15,10 +15,10 @@ use mmime::other::*;
 use crate::constants::Viewtype;
 use crate::contact::*;
 use crate::context::Context;
+use crate::dc_e2ee::*;
 use crate::dc_simplify::*;
 use crate::dc_strencode::*;
 use crate::dc_tools::*;
-use crate::e2ee::*;
 use crate::location;
 use crate::param::*;
 use crate::stock::StockMessage;
@@ -43,6 +43,7 @@ pub struct dc_mimepart_t {
 /* *
  * @class dc_mimeparser_t
  */
+#[derive(Clone)]
 #[allow(non_camel_case_types)]
 pub struct dc_mimeparser_t<'a> {
     pub parts: Vec<dc_mimepart_t>,
@@ -53,7 +54,7 @@ pub struct dc_mimeparser_t<'a> {
     pub subject: *mut libc::c_char,
     pub is_send_by_messenger: bool,
     pub decrypting_failed: libc::c_int,
-    pub e2ee_helper: E2eeHelper,
+    pub e2ee_helper: dc_e2ee_helper_t,
     pub is_forwarded: libc::c_int,
     pub context: &'a Context,
     pub reports: Vec<*mut mailmime>,
@@ -108,7 +109,7 @@ unsafe fn dc_mimeparser_empty(mimeparser: &mut dc_mimeparser_t) {
     mimeparser.is_forwarded = 0i32;
     mimeparser.reports.clear();
     mimeparser.decrypting_failed = 0i32;
-    mimeparser.e2ee_helper.thanks();
+    dc_e2ee_thanks(&mut mimeparser.e2ee_helper);
 
     mimeparser.location_kml = None;
     mimeparser.message_kml = None;
@@ -134,12 +135,14 @@ pub unsafe fn dc_mimeparser_parse<'a>(context: &'a Context, body: &[u8]) -> dc_m
         &mut mimeparser.mimeroot,
     );
     if r == MAILIMF_NO_ERROR as libc::c_int && !mimeparser.mimeroot.is_null() {
-        mimeparser
-            .e2ee_helper
-            .decrypt(mimeparser.context, mimeparser.mimeroot);
+        dc_e2ee_decrypt(
+            mimeparser.context,
+            mimeparser.mimeroot,
+            &mut mimeparser.e2ee_helper,
+        );
         let mimeparser_ref = &mut mimeparser;
         dc_mimeparser_parse_mime_recursive(mimeparser_ref, mimeparser_ref.mimeroot);
-        let field: *mut mailimf_field = dc_mimeparser_lookup_field(&mimeparser, "Subject");
+        let field: *mut mailimf_field = dc_mimeparser_lookup_field(&mut mimeparser, "Subject");
         if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_SUBJECT as libc::c_int {
             mimeparser.subject = dc_decode_header_words((*(*field).fld_data.fld_subject).sbj_value)
         }
@@ -1358,9 +1361,9 @@ unsafe fn do_add_single_file_part(
 }
 
 unsafe fn do_add_single_part(parser: &mut dc_mimeparser_t, mut part: dc_mimepart_t) {
-    if (*parser).e2ee_helper.encrypted && (*parser).e2ee_helper.signatures.len() > 0 {
+    if 0 != (*parser).e2ee_helper.encrypted && (*parser).e2ee_helper.signatures.len() > 0 {
         part.param.set_int(Param::GuranteeE2ee, 1);
-    } else if (*parser).e2ee_helper.encrypted {
+    } else if 0 != (*parser).e2ee_helper.encrypted {
         part.param.set_int(Param::ErroneousE2ee, 0x2);
     }
     parser.parts.push(part);
@@ -1815,22 +1818,19 @@ mod tests {
             let mut mimeparser = dc_mimeparser_parse(&context.ctx, &raw[..]);
 
             assert_eq!(
-                &to_string(mimeparser.subject as *const libc::c_char),
+                as_str(mimeparser.subject as *const libc::c_char),
                 "inner-subject",
             );
 
             let mut of: *mut mailimf_optional_field =
                 dc_mimeparser_lookup_optional_field(&mimeparser, "X-Special-A");
-            assert_eq!(
-                &to_string((*of).fld_value as *const libc::c_char),
-                "special-a",
-            );
+            assert_eq!(as_str((*of).fld_value as *const libc::c_char), "special-a",);
 
             of = dc_mimeparser_lookup_optional_field(&mimeparser, "Foo");
-            assert_eq!(&to_string((*of).fld_value as *const libc::c_char), "Bar",);
+            assert_eq!(as_str((*of).fld_value as *const libc::c_char), "Bar",);
 
             of = dc_mimeparser_lookup_optional_field(&mimeparser, "Chat-Version");
-            assert_eq!(&to_string((*of).fld_value as *const libc::c_char), "1.0",);
+            assert_eq!(as_str((*of).fld_value as *const libc::c_char), "1.0",);
             assert_eq!(mimeparser.parts.len(), 1);
 
             dc_mimeparser_unref(&mut mimeparser);

src/dc_move.rs

@@ -0,0 +1,44 @@
+use crate::constants::*;
+use crate::context::*;
+use crate::job::*;
+use crate::message::*;
+use crate::param::Params;
+
+pub unsafe fn dc_do_heuristics_moves(context: &Context, folder: &str, msg_id: u32) {
+    if context
+        .sql
+        .get_config_int(context, "mvbox_move")
+        .unwrap_or_else(|| 1)
+        == 0
+    {
+        return;
+    }
+
+    if !dc_is_inbox(context, folder) && !dc_is_sentbox(context, folder) {
+        return;
+    }
+
+    if let Ok(msg) = dc_msg_new_load(context, msg_id) {
+        if dc_msg_is_setupmessage(&msg) {
+            // do not move setup messages;
+            // there may be a non-delta device that wants to handle it
+            return;
+        }
+
+        if dc_is_mvbox(context, folder) {
+            dc_update_msg_move_state(context, msg.rfc724_mid, MoveState::Stay);
+        }
+
+        // 1 = dc message, 2 = reply to dc message
+        if 0 != msg.is_dc_message {
+            job_add(
+                context,
+                Action::MoveMsg,
+                msg.id as libc::c_int,
+                Params::new(),
+                0,
+            );
+            dc_update_msg_move_state(context, msg.rfc724_mid, MoveState::Moving);
+        }
+    }
+}

src/dc_receive_imf.rs

@@ -13,8 +13,9 @@ use sha2::{Digest, Sha256};
 use crate::chat::{self, Chat};
 use crate::constants::*;
 use crate::contact::*;
-use crate::context::{do_heuristics_moves, Context};
+use crate::context::Context;
 use crate::dc_mimeparser::*;
+use crate::dc_move::*;
 use crate::dc_securejoin::*;
 use crate::dc_strencode::*;
 use crate::dc_tools::*;
@@ -734,7 +735,7 @@ unsafe fn add_parts(
         }
     }
 
-    do_heuristics_moves(context, server_folder.as_ref(), *insert_msg_id);
+    dc_do_heuristics_moves(context, server_folder.as_ref(), *insert_msg_id);
     cleanup(mime_in_reply_to, mime_references, txt_raw);
 
     Ok(())
@@ -1761,7 +1762,7 @@ unsafe fn check_verified_properties(
         }
     };
 
-    if mimeparser.e2ee_helper.encrypted {
+    if 0 == mimeparser.e2ee_helper.encrypted {
         verify_fail("This message is not encrypted".into());
         return 0;
     }
@@ -1874,7 +1875,10 @@ unsafe fn dc_is_reply_to_known_message(
     if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_IN_REPLY_TO as libc::c_int {
         let fld_in_reply_to: *mut mailimf_in_reply_to = (*field).fld_data.fld_in_reply_to;
         if !fld_in_reply_to.is_null() {
-            if is_known_rfc724_mid_in_list(context, (*(*field).fld_data.fld_in_reply_to).mid_list) {
+            if 0 != is_known_rfc724_mid_in_list(
+                context,
+                (*(*field).fld_data.fld_in_reply_to).mid_list,
+            ) {
                 return 1;
             }
         }
@@ -1883,7 +1887,10 @@ unsafe fn dc_is_reply_to_known_message(
     if !field.is_null() && (*field).fld_type == MAILIMF_FIELD_REFERENCES as libc::c_int {
         let fld_references: *mut mailimf_references = (*field).fld_data.fld_references;
         if !fld_references.is_null() {
-            if is_known_rfc724_mid_in_list(context, (*(*field).fld_data.fld_references).mid_list) {
+            if 0 != is_known_rfc724_mid_in_list(
+                context,
+                (*(*field).fld_data.fld_references).mid_list,
+            ) {
                 return 1;
             }
         }
@@ -1891,18 +1898,29 @@ unsafe fn dc_is_reply_to_known_message(
     0
 }
 
-unsafe fn is_known_rfc724_mid_in_list(context: &Context, mid_list: *const clist) -> bool {
-    if mid_list.is_null() {
-        return false;
-    }
-
-    for data in &*mid_list {
-        if 0 != is_known_rfc724_mid(context, data.cast()) {
-            return true;
+unsafe fn is_known_rfc724_mid_in_list(context: &Context, mid_list: *const clist) -> libc::c_int {
+    if !mid_list.is_null() {
+        let mut cur: *mut clistiter;
+        cur = (*mid_list).first;
+        while !cur.is_null() {
+            if 0 != is_known_rfc724_mid(
+                context,
+                (if !cur.is_null() {
+                    (*cur).data
+                } else {
+                    ptr::null_mut()
+                }) as *const libc::c_char,
+            ) {
+                return 1;
+            }
+            cur = if !cur.is_null() {
+                (*cur).next
+            } else {
+                ptr::null_mut()
+            }
         }
     }
-
-    return false;
+    0
 }
 
 /// Check if a message is a reply to a known message (messenger or non-messenger).

src/dc_securejoin.rs

@@ -8,10 +8,10 @@ use crate::configure::*;
 use crate::constants::*;
 use crate::contact::*;
 use crate::context::Context;
+use crate::dc_e2ee::*;
 use crate::dc_mimeparser::*;
 use crate::dc_token::*;
 use crate::dc_tools::*;
-use crate::e2ee::*;
 use crate::key::*;
 use crate::lot::LotState;
 use crate::message::*;
@@ -30,41 +30,40 @@ pub unsafe fn dc_get_securejoin_qr(
     ====             Alice - the inviter side            ====
     ====   Step 1 in "Setup verified contact" protocol   ====
     ========================================================= */
-    let cleanup = |fingerprint, qr: Option<String>| {
+
+    let mut fingerprint = ptr::null_mut();
+    let mut invitenumber: *mut libc::c_char;
+    let mut auth: *mut libc::c_char;
+    let mut qr: Option<String> = None;
+
+    dc_ensure_secret_key_exists(context).ok();
+    invitenumber = dc_token_lookup(context, DC_TOKEN_INVITENUMBER, group_chat_id);
+    if invitenumber.is_null() {
+        invitenumber = dc_create_id().strdup();
+        dc_token_save(context, DC_TOKEN_INVITENUMBER, group_chat_id, invitenumber);
+    }
+    auth = dc_token_lookup(context, DC_TOKEN_AUTH, group_chat_id);
+    if auth.is_null() {
+        auth = dc_create_id().strdup();
+        dc_token_save(context, DC_TOKEN_AUTH, group_chat_id, auth);
+    }
+    let self_addr = context.sql.get_config(context, "configured_addr");
+
+    let cleanup = |fingerprint| {
         free(fingerprint as *mut libc::c_void);
+        free(invitenumber as *mut libc::c_void);
+        free(auth as *mut libc::c_void);
 
         if let Some(qr) = qr {
             qr.strdup()
         } else {
-            "".strdup()
+            std::ptr::null_mut()
         }
     };
 
-    let mut fingerprint = ptr::null_mut();
-    let mut qr: Option<String> = None;
-
-    ensure_secret_key_exists(context).ok();
-    let invitenumber = dc_token_lookup(context, DC_TOKEN_INVITENUMBER, group_chat_id)
-        .unwrap_or_else(|| {
-            let invitenumber_s = dc_create_id();
-            dc_token_save(
-                context,
-                DC_TOKEN_INVITENUMBER,
-                group_chat_id,
-                &invitenumber_s,
-            );
-            invitenumber_s
-        });
-    let auth = dc_token_lookup(context, DC_TOKEN_AUTH, group_chat_id).unwrap_or_else(|| {
-        let auth_s = dc_create_id();
-        dc_token_save(context, DC_TOKEN_AUTH, group_chat_id, &auth_s);
-        auth_s
-    });
-    let self_addr = context.sql.get_config(context, "configured_addr");
-
     if self_addr.is_none() {
         error!(context, 0, "Not configured, cannot generate QR code.",);
-        return cleanup(fingerprint, qr);
+        return cleanup(fingerprint);
     }
 
     let self_addr = self_addr.unwrap();
@@ -76,7 +75,7 @@ pub unsafe fn dc_get_securejoin_qr(
     fingerprint = get_self_fingerprint(context);
 
     if fingerprint.is_null() {
-        return cleanup(fingerprint, qr);
+        return cleanup(fingerprint);
     }
 
     let self_addr_urlencoded = utf8_percent_encode(&self_addr, NON_ALPHANUMERIC).to_string();
@@ -94,15 +93,15 @@ pub unsafe fn dc_get_securejoin_qr(
                 self_addr_urlencoded,
                 &group_name_urlencoded,
                 &chat.grpid,
-                &invitenumber,
-                &auth,
+                as_str(invitenumber),
+                as_str(auth),
             ))
         } else {
             error!(
                 context,
                 0, "Cannot get QR-code for chat-id {}", group_chat_id,
             );
-            return cleanup(fingerprint, qr);
+            return cleanup(fingerprint);
         }
     } else {
         Some(format!(
@@ -110,14 +109,14 @@ pub unsafe fn dc_get_securejoin_qr(
             as_str(fingerprint),
             self_addr_urlencoded,
             self_name_urlencoded,
-            &invitenumber,
-            &auth,
+            as_str(invitenumber),
+            as_str(auth),
         ))
     };
 
     info!(context, 0, "Generated QR code: {}", qr.as_ref().unwrap());
 
-    return cleanup(fingerprint, qr);
+    cleanup(fingerprint)
 }
 
 fn get_self_fingerprint(context: &Context) -> *mut libc::c_char {
@@ -141,7 +140,7 @@ pub unsafe fn dc_join_securejoin(context: &Context, qr: *const libc::c_char) ->
     let mut join_vg: libc::c_int = 0i32;
 
     info!(context, 0, "Requesting secure-join ...",);
-    ensure_secret_key_exists(context).ok();
+    dc_ensure_secret_key_exists(context).ok();
     ongoing_allocated = dc_alloc_ongoing(context);
 
     if !(ongoing_allocated == 0i32) {
@@ -415,7 +414,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
                 if invitenumber.is_null() {
                     warn!(context, 0, "Secure-join denied (invitenumber missing).",);
                     ok_to_continue = false;
-                } else if !dc_token_exists(context, DC_TOKEN_INVITENUMBER, as_str(invitenumber)) {
+                } else if !dc_token_exists(context, DC_TOKEN_INVITENUMBER, invitenumber) {
                     warn!(context, 0, "Secure-join denied (bad invitenumber).",);
                     ok_to_continue = false;
                 } else {
@@ -503,7 +502,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
                         could_not_establish_secure_connection(
                             context,
                             contact_chat_id,
-                            if mimeparser.e2ee_helper.encrypted {
+                            if 0 != mimeparser.e2ee_helper.encrypted {
                                 b"No valid signature.\x00" as *const u8 as *const libc::c_char
                             } else {
                                 b"Not encrypted.\x00" as *const u8 as *const libc::c_char
@@ -603,7 +602,7 @@ pub unsafe fn dc_handle_securejoin_handshake(
                             b"Auth not provided.\x00" as *const u8 as *const libc::c_char,
                         );
                         ok_to_continue = false;
-                    } else if !dc_token_exists(context, DC_TOKEN_AUTH, as_str(auth_0)) {
+                    } else if !dc_token_exists(context, DC_TOKEN_AUTH, auth_0) {
                         could_not_establish_secure_connection(
                             context,
                             contact_chat_id,
@@ -942,7 +941,7 @@ unsafe fn encrypted_and_signed(
     mimeparser: &dc_mimeparser_t,
     expected_fingerprint: impl AsRef<str>,
 ) -> bool {
-    if !mimeparser.e2ee_helper.encrypted {
+    if 0 == mimeparser.e2ee_helper.encrypted {
         warn!(mimeparser.context, 0, "Message not encrypted.",);
         return false;
     }

src/dc_token.rs

@@ -14,14 +14,17 @@ pub fn dc_token_save(
     context: &Context,
     namespc: dc_tokennamespc_t,
     foreign_id: u32,
-    token: &str,
+    token: *const libc::c_char,
 ) -> bool {
+    if token.is_null() {
+        return false;
+    }
     // foreign_id may be 0
     sql::execute(
         context,
         &context.sql,
         "INSERT INTO tokens (namespc, foreign_id, token, timestamp) VALUES (?, ?, ?, ?);",
-        params![namespc as i32, foreign_id as i32, token, time()],
+        params![namespc as i32, foreign_id as i32, as_str(token), time()],
     )
     .is_ok()
 }
@@ -30,21 +33,33 @@ pub fn dc_token_lookup(
     context: &Context,
     namespc: dc_tokennamespc_t,
     foreign_id: u32,
-) -> Option<String> {
-    context.sql.query_row_col::<_, String>(
-        context,
-        "SELECT token FROM tokens WHERE namespc=? AND foreign_id=?;",
-        params![namespc as i32, foreign_id as i32],
-        0,
-    )
+) -> *mut libc::c_char {
+    context
+        .sql
+        .query_row_col::<_, String>(
+            context,
+            "SELECT token FROM tokens WHERE namespc=? AND foreign_id=?;",
+            params![namespc as i32, foreign_id as i32],
+            0,
+        )
+        .map(|s| unsafe { s.strdup() })
+        .unwrap_or_else(|| std::ptr::null_mut())
 }
 
-pub fn dc_token_exists(context: &Context, namespc: dc_tokennamespc_t, token: &str) -> bool {
+pub fn dc_token_exists(
+    context: &Context,
+    namespc: dc_tokennamespc_t,
+    token: *const libc::c_char,
+) -> bool {
+    if token.is_null() {
+        return false;
+    }
+
     context
         .sql
         .exists(
             "SELECT id FROM tokens WHERE namespc=? AND token=?;",
-            params![namespc as i32, token],
+            params![namespc as i32, as_str(token)],
         )
         .unwrap_or_default()
 }

src/lib.rs

@@ -30,7 +30,6 @@ pub mod configure;
 pub mod constants;
 pub mod contact;
 pub mod context;
-mod e2ee;
 mod imap;
 pub mod job;
 mod job_thread;
@@ -52,10 +51,12 @@ pub mod x;
 
 pub mod dc_array;
 mod dc_dehtml;
+mod dc_e2ee;
 pub mod dc_imex;
 mod dc_loginparam;
 mod dc_mimefactory;
 pub mod dc_mimeparser;
+mod dc_move;
 pub mod dc_receive_imf;
 pub mod dc_securejoin;
 mod dc_simplify;