avoids double-semicolon problem leading to empty messages in pre-master releases

Switch mailparsing to mailparse

.gitignore

@@ -23,3 +23,5 @@ python/liveconfig*
 # ignore doxgen generated files
 deltachat-ffi/html
 deltachat-ffi/xml
+
+.rsynclist

CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog 
 
+## 1.0.0-beta.9
+
+- historic: we now use the mailparse crate and lettre-email to generate mime
+  messages.  This got rid of mmime completely, the C2rust generated port of the libetpan 
+  mime-parse -- IOW 22KLocs of cumbersome code removed! see 
+  https://github.com/deltachat/deltachat-core-rust/pull/904#issuecomment-561163330
+  many thanks @dignifiedquire for making everybody's life easier 
+  and @jonhoo (from rust-imap fame) for suggesting to use the mailparse crate :) 
+
+- lots of improvements and better error handling in many rust modules 
+  thanks @link2xt @flub @r10s, @hpk42 and @dignifiedquire 
+
+- @r10s introduced a new device chat which has an initial
+  welcome message.  See 
+  https://c.delta.chat/classdc__context__t.html#a1a2aad98bd23c1d21ee42374e241f389
+  for the main new FFI-API.
+
+- fix moving self-sent messages, thanks @r10s, @flub, @hpk42
+
+- fix flakyness/sometimes-failing verified/join-protocols, 
+  thanks @flub, @r10s, @hpk42
+
+- new DC_EVENT_SECUREJOIN_SUCCEEDED event 
+
+- many little fixes and rustifications (@link2xt, @flub, @hpk42)
+
+
 ## 1.0.0-beta.8
 
 - now uses async-email/async-imap as the new base 

Cargo.toml

@@ -7,7 +7,6 @@ license = "MPL"
 
 [dependencies]
 deltachat_derive = { path = "./deltachat_derive" }
-mmime = { version = "0.1.2", path = "./mmime" }
 
 libc = "0.2.51"
 pgp = { git = "https://github.com/rpgp/rpgp", branch = "master", default-features = false }
@@ -18,11 +17,12 @@ smallvec = "0.6.9"
 reqwest = { version = "0.9.15", default-features = false, features = ["rustls-tls"] }
 num-derive = "0.2.5"
 num-traits = "0.2.6"
-lettre = { git = "https://github.com/deltachat/lettre", branch = "feat/rustls" }
+lettre = { git = "https://github.com/deltachat/lettre", branch = "feat/mail" }
+lettre_email = { git = "https://github.com/deltachat/lettre", branch = "feat/mail" }
 async-imap = { git = "https://github.com/async-email/async-imap", branch="master" }
 async-tls = "0.6"
 async-std = { version = "1.0", features = ["unstable"] }
-base64 = "0.10"
+base64 = "0.11"
 charset = "0.1"
 percent-encoding = "2.0"
 serde = { version = "1.0", features = ["derive"] }
@@ -47,13 +47,13 @@ image-meta = "0.1.0"
 quick-xml = "0.15.0"
 escaper = "0.1.0"
 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"
+mailparse = "0.10.1"
 
 [dev-dependencies]
 tempfile = "3.0"
@@ -65,7 +65,6 @@ proptest = "0.9.4"
 members = [
   "deltachat-ffi",
   "deltachat_derive",
-  "mmime",
 ]
 
 [[example]]

appveyor.yml

@@ -1,5 +1,4 @@
 environment:
-  RUST_BACKTRACE: full
   matrix:
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
 

assets/icon-device.svg

@@ -5,10 +5,9 @@
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:svg="http://www.w3.org/2000/svg"
    xmlns="http://www.w3.org/2000/svg"
-   xmlns:xlink="http://www.w3.org/1999/xlink"
    xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
    xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   inkscape:version="1.0beta1 (32d4812, 2019-09-19)"
+   inkscape:version="0.92.4 5da689c313, 2019-01-14"
    sodipodi:docname="icon-device.svg"
    id="svg4344"
    preserveAspectRatio="xMidYMid meet"
@@ -16,46 +15,24 @@
    height="60"
    width="60"
    version="1.0"
-   inkscape:export-filename="/Users/bpetersen/Documents/deltachat/icons/device4.png"
-   inkscape:export-xdpi="96"
-   inkscape:export-ydpi="96">
+   inkscape:export-filename="/home/kerle/Workspace/deltachat-core-rust/assets/icon-device.png"
+   inkscape:export-xdpi="409.60001"
+   inkscape:export-ydpi="409.60001">
   <defs
-     id="defs4348">
-    <linearGradient
-       inkscape:collect="always"
-       id="linearGradient865">
-      <stop
-         style="stop-color:#364e59;stop-opacity:1;"
-         offset="0"
-         id="stop861" />
-      <stop
-         style="stop-color:#ffffff;stop-opacity:1"
-         offset="1"
-         id="stop863" />
-    </linearGradient>
-    <linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient865"
-       id="linearGradient867"
-       x1="10.227795"
-       y1="43.5238"
-       x2="-25.458139"
-       y2="-7.4257693"
-       gradientUnits="userSpaceOnUse" />
-  </defs>
+     id="defs4348" />
   <sodipodi:namedview
      inkscape:current-layer="svg4344"
      inkscape:window-maximized="0"
-     inkscape:window-y="23"
-     inkscape:window-x="45"
+     inkscape:window-y="0"
+     inkscape:window-x="0"
      inkscape:cy="28.471578"
-     inkscape:cx="41.455164"
+     inkscape:cx="28.03926"
      inkscape:zoom="5.6"
      units="px"
      showgrid="false"
      id="namedview4346"
-     inkscape:window-height="1035"
-     inkscape:window-width="1600"
+     inkscape:window-height="1019"
+     inkscape:window-width="1248"
      inkscape:pageshadow="2"
      inkscape:pageopacity="0"
      guidetolerance="10"
@@ -64,7 +41,8 @@
      borderopacity="1"
      inkscape:document-rotation="0"
      bordercolor="#666666"
-     pagecolor="#ffffff" />
+     pagecolor="#ffffff"
+     inkscape:snap-global="false" />
   <metadata
      id="metadata4336">
 Created by potrace 1.15, written by Peter Selinger 2001-2017
@@ -89,13 +67,15 @@ Created by potrace 1.15, written by Peter Selinger 2001-2017
      cy="22.5"
      cx="22.5"
      id="path4917"
-     style="fill:url(#linearGradient867);fill-opacity:1;stroke-width:0.588554" />
+     style="fill:#364e54;fill-opacity:0.67681497;stroke-width:0.58855402"
+     inkscape:export-xdpi="409"
+     inkscape:export-ydpi="409" />
   <g
      id="g4342"
-     stroke="none"
-     fill="#000000"
      transform="matrix(0.00255113,0,0,-0.00255113,5.586152,38.200477)"
-     style="fill:#ffffff;fill-opacity:1">
+     style="fill:#ffffff;fill-opacity:1"
+     stroke="none"
+     fill="#000000">
     <path
        inkscape:connector-curvature="0"
        id="path4338"

assets/icon-saved-messages.svg

@@ -5,67 +5,44 @@
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:svg="http://www.w3.org/2000/svg"
    xmlns="http://www.w3.org/2000/svg"
-   xmlns:xlink="http://www.w3.org/1999/xlink"
    xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
    xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   inkscape:export-ydpi="204.8"
-   inkscape:export-xdpi="204.8"
-   inkscape:export-filename="/Users/bpetersen/Documents/deltachat/icons/saved-messages.png"
-   version="1.0"
-   width="60"
-   height="60"
-   viewBox="0 0 45 45"
-   preserveAspectRatio="xMidYMid meet"
+   inkscape:version="0.92.4 5da689c313, 2019-01-14"
+   sodipodi:docname="icon-saved-messages.svg"
    id="svg4344"
-   sodipodi:docname="saved-messages.svg"
-   inkscape:version="1.0beta1 (32d4812, 2019-09-19)">
+   preserveAspectRatio="xMidYMid meet"
+   viewBox="0 0 45 45"
+   height="60"
+   width="60"
+   version="1.0"
+   inkscape:export-filename="/home/kerle/test-icon.png"
+   inkscape:export-xdpi="409.60001"
+   inkscape:export-ydpi="409.60001">
   <defs
-     id="defs4348">
-    <linearGradient
-       inkscape:collect="always"
-       id="linearGradient906">
-      <stop
-         style="stop-color:#046cdb;stop-opacity:1"
-         offset="0"
-         id="stop902" />
-      <stop
-         id="stop845"
-         offset="1"
-         style="stop-color:#ffffff;stop-opacity:1" />
-    </linearGradient>
-    <linearGradient
-       y2="-11.049108"
-       x2="-3.1473193"
-       y1="31.473215"
-       x1="36.160713"
-       gradientUnits="userSpaceOnUse"
-       id="linearGradient847"
-       xlink:href="#linearGradient906"
-       inkscape:collect="always" />
-  </defs>
+     id="defs4348" />
   <sodipodi:namedview
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     inkscape:document-rotation="0"
-     borderopacity="1"
-     objecttolerance="10"
-     gridtolerance="10"
-     guidetolerance="10"
-     inkscape:pageopacity="0"
-     inkscape:pageshadow="2"
-     inkscape:window-width="1600"
-     inkscape:window-height="1035"
-     id="namedview4346"
-     showgrid="false"
-     units="px"
-     inkscape:zoom="2.8"
-     inkscape:cx="48.214285"
-     inkscape:cy="55"
-     inkscape:window-x="45"
-     inkscape:window-y="23"
-     inkscape:window-maximized="0"
+     inkscape:lockguides="false"
      inkscape:current-layer="svg4344"
-     inkscape:lockguides="false" />
+     inkscape:window-maximized="0"
+     inkscape:window-y="130"
+     inkscape:window-x="89"
+     inkscape:cy="43.28624"
+     inkscape:cx="-21.066324"
+     inkscape:zoom="4"
+     units="px"
+     showgrid="false"
+     id="namedview4346"
+     inkscape:window-height="855"
+     inkscape:window-width="1395"
+     inkscape:pageshadow="2"
+     inkscape:pageopacity="0"
+     guidetolerance="10"
+     gridtolerance="10"
+     objecttolerance="10"
+     borderopacity="1"
+     inkscape:document-rotation="0"
+     bordercolor="#666666"
+     pagecolor="#ffffff" />
   <metadata
      id="metadata4336">
 Created by potrace 1.15, written by Peter Selinger 2001-2017
@@ -80,20 +57,20 @@ Created by potrace 1.15, written by Peter Selinger 2001-2017
 </rdf:RDF>
 </metadata>
   <circle
-     r="22.5"
-     cy="22.5"
-     cx="22.5"
+     style="opacity:1;fill:#ffffff;fill-opacity:1;stroke-width:0.731071"
      id="path859"
-     style="opacity:1;fill:#ffffff;fill-opacity:1;stroke-width:0.731071" />
-  <circle
-     style="fill:url(#linearGradient847);fill-opacity:1;stroke-width:0.588554"
-     id="path4917"
      cx="22.5"
      cy="22.5"
      r="22.5" />
+  <circle
+     r="22.5"
+     cy="22.50293"
+     cx="22.5"
+     id="path4917"
+     style="fill:#87aade;fill-opacity:1;stroke-width:0.58855402" />
   <path
-     id="rect846"
-     style="fill:#ffffff;stroke-width:0.84832"
-     d="M 17 9 L 17 55 L 17.125 55 L 30.048828 40.9375 L 42.974609 55 L 43 55 L 43 9 L 17 9 z M 30.005859 15 L 32.720703 22.121094 L 40 22.646484 L 34.396484 27.558594 L 36.169922 35 L 29.992188 30.916016 L 23.808594 34.988281 L 25.595703 27.550781 L 20 22.626953 L 27.28125 22.115234 L 30.005859 15 z "
-     transform="scale(0.75)" />
+     inkscape:connector-curvature="0"
+     d="M 13.5,7.5 V 39 h 0.08654 L 22.533801,29.370239 31.482419,39 h 0.01758 V 7.5 Z m 9.004056,4.108698 1.879508,4.876388 5.039514,0.359779 -3.879358,3.363728 1.227764,5.095749 -4.276893,-2.796643 -4.280949,2.788618 1.237229,-5.093073 -3.873949,-3.371754 5.040866,-0.350417 z"
+     style="fill:#ffffff;stroke-width:0.58409804"
+     id="rect846" />
 </svg>

deltachat-ffi/Cargo.toml

@@ -20,6 +20,7 @@ deltachat-provider-database = "0.2.1"
 libc = "0.2"
 human-panic = "1.0.1"
 num-traits = "0.2.6"
+failure = "0.1.6"
 
 [features]
 default = ["vendored", "nightly", "ringbuf"]

deltachat-ffi/deltachat.h

@@ -1139,6 +1139,24 @@ void            dc_set_draft                 (dc_context_t* context, uint32_t ch
 uint32_t        dc_add_device_msg            (dc_context_t* context, const char* label, dc_msg_t* msg);
 
 
+/**
+ * Init device-messages and saved-messages chat.
+ * This function adds the device-chat and saved-messages chat
+ * and adds one or more welcome or update-messages.
+ * The ui can add messages on its own using dc_add_device_msg() -
+ * for ordering, either before or after or even without calling this function.
+ *
+ * Chat and message creation is done only once.
+ * So if the user has manually deleted things, they won't be re-created
+ * (however, not seen device messages are added and may re-create the device-chat).
+ *
+ * @memberof dc_context_t
+ * @param context The context as created by dc_context_new().
+ * @return None.
+ */
+void            dc_update_device_chats       (dc_context_t* context);
+
+
 /**
  * Check if a device-message with a given label was ever added.
  * Device-messages can be added dc_add_device_msg().

deltachat-ffi/src/lib.rs

@@ -24,14 +24,14 @@ use num_traits::{FromPrimitive, ToPrimitive};
 
 use deltachat::constants::DC_MSG_ID_LAST_SPECIAL;
 use deltachat::contact::Contact;
-use deltachat::context::{Context, ContextBuilder};
-use deltachat::dc_tools::{
-    as_path, dc_strdup, to_opt_string_lossy, to_string_lossy, OsStrExt, StrExt,
-};
+use deltachat::context::Context;
 use deltachat::message::MsgId;
 use deltachat::stock::StockMessage;
 use deltachat::*;
 
+mod string;
+use self::string::*;
+
 // as C lacks a good and portable error handling,
 // in general, the C Interface is forgiving wrt to bad parameters.
 // - objects returned by some functions
@@ -248,15 +248,22 @@ pub unsafe extern "C" fn dc_open(
     }
     let ffi_context = &*context;
     let rust_cb = move |_ctx: &Context, evt: Event| ffi_context.translate_cb(evt);
-    let mut builder = ContextBuilder::new(
-        Box::new(rust_cb),
-        ffi_context.os_name.clone(),
-        as_path(dbfile).to_path_buf(),
-    );
-    if !blobdir.is_null() && *blobdir != 0 {
-        builder = builder.blobdir(as_path(blobdir).to_path_buf());
-    }
-    match builder.create() {
+
+    let ctx = if blobdir.is_null() || *blobdir == 0 {
+        Context::new(
+            Box::new(rust_cb),
+            ffi_context.os_name.clone(),
+            as_path(dbfile).to_path_buf(),
+        )
+    } else {
+        Context::with_blobdir(
+            Box::new(rust_cb),
+            ffi_context.os_name.clone(),
+            as_path(dbfile).to_path_buf(),
+            as_path(blobdir).to_path_buf(),
+        )
+    };
+    match ctx {
         Ok(ctx) => {
             let mut inner_guard = ffi_context.inner.write().unwrap();
             *inner_guard = Some(ctx);
@@ -844,6 +851,21 @@ pub unsafe extern "C" fn dc_add_device_msg(
         .unwrap_or(0)
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn dc_update_device_chats(context: *mut dc_context_t) {
+    if context.is_null() {
+        eprintln!("ignoring careless call to dc_update_device_chats()");
+        return;
+    }
+    let ffi_context = &mut *context;
+    ffi_context
+        .with_inner(|ctx| {
+            ctx.update_device_chats()
+                .unwrap_or_log_default(ctx, "Failed to add device message")
+        })
+        .unwrap_or(())
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_was_device_msg_ever_added(
     context: *mut dc_context_t,

deltachat-ffi/src/providers.rs

@@ -2,7 +2,7 @@ extern crate deltachat_provider_database;
 
 use std::ptr;
 
-use deltachat::dc_tools::{to_string_lossy, StrExt};
+use crate::string::{to_string_lossy, StrExt};
 use deltachat_provider_database::StatusState;
 
 #[no_mangle]

deltachat-ffi/src/string.rs

@@ -0,0 +1,350 @@
+use failure::Fail;
+use std::ffi::{CStr, CString};
+
+/// Duplicates a string
+///
+/// returns an empty string if NULL is given, never returns NULL (exits on errors)
+///
+/// # Examples
+///
+/// ```rust,norun
+/// use deltachat::dc_tools::{dc_strdup, to_string_lossy};
+/// unsafe {
+///     let str_a = b"foobar\x00" as *const u8 as *const libc::c_char;
+///     let str_a_copy = dc_strdup(str_a);
+///     assert_eq!(to_string_lossy(str_a_copy), "foobar");
+///     assert_ne!(str_a, str_a_copy);
+/// }
+/// ```
+pub unsafe fn dc_strdup(s: *const libc::c_char) -> *mut libc::c_char {
+    let ret: *mut libc::c_char;
+    if !s.is_null() {
+        ret = libc::strdup(s);
+        assert!(!ret.is_null());
+    } else {
+        ret = libc::calloc(1, 1) as *mut libc::c_char;
+        assert!(!ret.is_null());
+    }
+
+    ret
+}
+
+/// Error type for the [OsStrExt] trait
+#[derive(Debug, Fail, PartialEq)]
+pub enum CStringError {
+    /// The string contains an interior null byte
+    #[fail(display = "String contains an interior null byte")]
+    InteriorNullByte,
+    /// The string is not valid Unicode
+    #[fail(display = "String is not valid unicode")]
+    NotUnicode,
+}
+
+/// Extra convenience methods on [std::ffi::OsStr] to work with `*libc::c_char`.
+///
+/// The primary function of this trait is to more easily convert
+/// [OsStr], [OsString] or [Path] into pointers to C strings.  This always
+/// allocates a new string since it is very common for the source
+/// string not to have the required terminal null byte.
+///
+/// It is implemented for `AsRef<std::ffi::OsStr>>` trait, which
+/// allows any type which implements this trait to transparently use
+/// this.  This is how the conversion for [Path] works.
+///
+/// [OsStr]: std::ffi::OsStr
+/// [OsString]: std::ffi::OsString
+/// [Path]: std::path::Path
+///
+/// # Example
+///
+/// ```
+/// use deltachat::dc_tools::{dc_strdup, OsStrExt};
+/// let path = std::path::Path::new("/some/path");
+/// let path_c = path.to_c_string().unwrap();
+/// unsafe {
+///     let mut c_ptr: *mut libc::c_char = dc_strdup(path_c.as_ptr());
+/// }
+/// ```
+pub trait OsStrExt {
+    /// Convert a  [std::ffi::OsStr] to an [std::ffi::CString]
+    ///
+    /// This is useful to convert e.g. a [std::path::Path] to
+    /// [*libc::c_char] by using
+    /// [Path::as_os_str()](std::path::Path::as_os_str) and
+    /// [CStr::as_ptr()](std::ffi::CStr::as_ptr).
+    ///
+    /// This returns [CString] and not [&CStr] because not all [OsStr]
+    /// slices end with a null byte, particularly those coming from
+    /// [Path] do not have a null byte and having to handle this as
+    /// the caller would defeat the point of this function.
+    ///
+    /// On Windows this requires that the [OsStr] contains valid
+    /// unicode, which should normally be the case for a [Path].
+    ///
+    /// [CString]: std::ffi::CString
+    /// [CStr]: std::ffi::CStr
+    /// [OsStr]: std::ffi::OsStr
+    /// [Path]: std::path::Path
+    ///
+    /// # Errors
+    ///
+    /// Since a C `*char` is terminated by a NULL byte this conversion
+    /// will fail, when the [OsStr] has an interior null byte.  The
+    /// function will return
+    /// `[Err]([CStringError::InteriorNullByte])`.  When converting
+    /// from a [Path] it should be safe to
+    /// [`.unwrap()`](std::result::Result::unwrap) this anyway since a
+    /// [Path] should not contain interior null bytes.
+    ///
+    /// On windows when the string contains invalid Unicode
+    /// `[Err]([CStringError::NotUnicode])` is returned.
+    fn to_c_string(&self) -> Result<CString, CStringError>;
+}
+
+impl<T: AsRef<std::ffi::OsStr>> OsStrExt for T {
+    #[cfg(not(target_os = "windows"))]
+    fn to_c_string(&self) -> Result<CString, CStringError> {
+        use std::os::unix::ffi::OsStrExt;
+        CString::new(self.as_ref().as_bytes()).map_err(|err| match err {
+            std::ffi::NulError { .. } => CStringError::InteriorNullByte,
+        })
+    }
+
+    #[cfg(target_os = "windows")]
+    fn to_c_string(&self) -> Result<CString, CStringError> {
+        os_str_to_c_string_unicode(&self)
+    }
+}
+
+// Implementation for os_str_to_c_string on windows.
+#[allow(dead_code)]
+fn os_str_to_c_string_unicode(
+    os_str: &dyn AsRef<std::ffi::OsStr>,
+) -> Result<CString, CStringError> {
+    match os_str.as_ref().to_str() {
+        Some(val) => CString::new(val.as_bytes()).map_err(|err| match err {
+            std::ffi::NulError { .. } => CStringError::InteriorNullByte,
+        }),
+        None => Err(CStringError::NotUnicode),
+    }
+}
+
+/// Convenience methods/associated functions for working with [CString]
+///
+/// This is helps transitioning from unsafe code.
+pub trait CStringExt {
+    /// Create a new [CString], yolo style
+    ///
+    /// This unwrap the result, panicking when there are embedded NULL
+    /// bytes.
+    fn yolo<T: Into<Vec<u8>>>(t: T) -> CString {
+        CString::new(t).expect("String contains null byte, can not be CString")
+    }
+}
+
+impl CStringExt for CString {}
+
+/// Convenience methods to make transitioning from raw C strings easier.
+///
+/// To interact with (legacy) C APIs we often need to convert from
+/// Rust strings to raw C strings.  This can be clumsy to do correctly
+/// and the compiler sometimes allows it in an unsafe way.  These
+/// methods make it more succinct and help you get it right.
+pub trait StrExt {
+    /// Allocate a new raw C `*char` version of this string.
+    ///
+    /// This allocates a new raw C string which must be freed using
+    /// `free`.  It takes care of some common pitfalls with using
+    /// [CString.as_ptr].
+    ///
+    /// [CString.as_ptr]: std::ffi::CString.as_ptr
+    ///
+    /// # Panics
+    ///
+    /// This function will panic when the original string contains an
+    /// interior null byte as this can not be represented in raw C
+    /// strings.
+    unsafe fn strdup(&self) -> *mut libc::c_char;
+}
+
+impl<T: AsRef<str>> StrExt for T {
+    unsafe fn strdup(&self) -> *mut libc::c_char {
+        let tmp = CString::yolo(self.as_ref());
+        dc_strdup(tmp.as_ptr())
+    }
+}
+
+pub fn to_string_lossy(s: *const libc::c_char) -> String {
+    if s.is_null() {
+        return "".into();
+    }
+
+    let cstr = unsafe { CStr::from_ptr(s) };
+
+    cstr.to_string_lossy().to_string()
+}
+
+pub fn to_opt_string_lossy(s: *const libc::c_char) -> Option<String> {
+    if s.is_null() {
+        return None;
+    }
+
+    Some(to_string_lossy(s))
+}
+
+/// Convert a C `*char` pointer to a [std::path::Path] slice.
+///
+/// This converts a `*libc::c_char` pointer to a [Path] slice.  This
+/// essentially has to convert the pointer to [std::ffi::OsStr] to do
+/// so and thus is the inverse of [OsStrExt::to_c_string].  Just like
+/// [OsStrExt::to_c_string] requires valid Unicode on Windows, this
+/// requires that the pointer contains valid UTF-8 on Windows.
+///
+/// Because this returns a reference the [Path] silce can not outlive
+/// the original pointer.
+///
+/// [Path]: std::path::Path
+#[cfg(not(target_os = "windows"))]
+pub fn as_path<'a>(s: *const libc::c_char) -> &'a std::path::Path {
+    assert!(!s.is_null(), "cannot be used on null pointers");
+    use std::os::unix::ffi::OsStrExt;
+    unsafe {
+        let c_str = std::ffi::CStr::from_ptr(s).to_bytes();
+        let os_str = std::ffi::OsStr::from_bytes(c_str);
+        std::path::Path::new(os_str)
+    }
+}
+
+// as_path() implementation for windows, documented above.
+#[cfg(target_os = "windows")]
+pub fn as_path<'a>(s: *const libc::c_char) -> &'a std::path::Path {
+    as_path_unicode(s)
+}
+
+// Implementation for as_path() on Windows.
+//
+// Having this as a separate function means it can be tested on unix
+// too.
+#[allow(dead_code)]
+fn as_path_unicode<'a>(s: *const libc::c_char) -> &'a std::path::Path {
+    assert!(!s.is_null(), "cannot be used on null pointers");
+
+    let cstr = unsafe { CStr::from_ptr(s) };
+    let str = cstr.to_str().unwrap_or_else(|err| panic!("{}", err));
+
+    std::path::Path::new(str)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use libc::{free, strcmp};
+
+    #[test]
+    fn test_os_str_to_c_string_cwd() {
+        let some_dir = std::env::current_dir().unwrap();
+        some_dir.as_os_str().to_c_string().unwrap();
+    }
+
+    #[test]
+    fn test_os_str_to_c_string_unicode() {
+        let some_str = String::from("/some/valid/utf8");
+        let some_dir = std::path::Path::new(&some_str);
+        assert_eq!(
+            some_dir.as_os_str().to_c_string().unwrap(),
+            CString::new("/some/valid/utf8").unwrap()
+        );
+    }
+
+    #[test]
+    fn test_os_str_to_c_string_nul() {
+        let some_str = std::ffi::OsString::from("foo\x00bar");
+        assert_eq!(
+            some_str.to_c_string().err().unwrap(),
+            CStringError::InteriorNullByte
+        )
+    }
+
+    #[test]
+    fn test_path_to_c_string_cwd() {
+        let some_dir = std::env::current_dir().unwrap();
+        some_dir.to_c_string().unwrap();
+    }
+
+    #[test]
+    fn test_path_to_c_string_unicode() {
+        let some_str = String::from("/some/valid/utf8");
+        let some_dir = std::path::Path::new(&some_str);
+        assert_eq!(
+            some_dir.as_os_str().to_c_string().unwrap(),
+            CString::new("/some/valid/utf8").unwrap()
+        );
+    }
+
+    #[test]
+    fn test_os_str_to_c_string_unicode_fn() {
+        let some_str = std::ffi::OsString::from("foo");
+        assert_eq!(
+            os_str_to_c_string_unicode(&some_str).unwrap(),
+            CString::new("foo").unwrap()
+        );
+    }
+
+    #[test]
+    fn test_path_to_c_string_unicode_fn() {
+        let some_str = String::from("/some/path");
+        let some_path = std::path::Path::new(&some_str);
+        assert_eq!(
+            os_str_to_c_string_unicode(&some_path).unwrap(),
+            CString::new("/some/path").unwrap()
+        );
+    }
+
+    #[test]
+    fn test_os_str_to_c_string_unicode_fn_nul() {
+        let some_str = std::ffi::OsString::from("fooz\x00bar");
+        assert_eq!(
+            os_str_to_c_string_unicode(&some_str).err().unwrap(),
+            CStringError::InteriorNullByte
+        );
+    }
+
+    #[test]
+    fn test_as_path() {
+        let some_path = CString::new("/some/path").unwrap();
+        let ptr = some_path.as_ptr();
+        assert_eq!(as_path(ptr), std::ffi::OsString::from("/some/path"))
+    }
+
+    #[test]
+    fn test_as_path_unicode_fn() {
+        let some_path = CString::new("/some/path").unwrap();
+        let ptr = some_path.as_ptr();
+        assert_eq!(as_path_unicode(ptr), std::ffi::OsString::from("/some/path"));
+    }
+
+    #[test]
+    fn test_cstring_yolo() {
+        assert_eq!(CString::new("hello").unwrap(), CString::yolo("hello"));
+    }
+
+    #[test]
+    fn test_strdup_str() {
+        unsafe {
+            let s = "hello".strdup();
+            let cmp = strcmp(s, b"hello\x00" as *const u8 as *const libc::c_char);
+            free(s as *mut libc::c_void);
+            assert_eq!(cmp, 0);
+        }
+    }
+
+    #[test]
+    fn test_strdup_string() {
+        unsafe {
+            let s = String::from("hello").strdup();
+            let cmp = strcmp(s, b"hello\x00" as *const u8 as *const libc::c_char);
+            free(s as *mut libc::c_void);
+            assert_eq!(cmp, 0);
+        }
+    }
+}

examples/repl/cmdline.rs

@@ -19,12 +19,11 @@ use deltachat::peerstate::*;
 use deltachat::qr::*;
 use deltachat::sql;
 use deltachat::Event;
-use libc::free;
 
 /// Reset database tables. This function is called from Core cmdline.
 /// Argument is a bitmask, executing single or multiple actions in one call.
 /// e.g. bitmask 7 triggers actions definded with bits 1, 2 and 4.
-pub unsafe fn dc_reset_tables(context: &Context, bits: i32) -> i32 {
+pub fn dc_reset_tables(context: &Context, bits: i32) -> i32 {
     info!(context, "Resetting tables ({})...", bits);
     if 0 != bits & 1 {
         sql::execute(context, &context.sql, "DELETE FROM jobs;", params![]).unwrap();
@@ -95,7 +94,7 @@ pub unsafe fn dc_reset_tables(context: &Context, bits: i32) -> i32 {
 fn dc_poke_eml_file(context: &Context, filename: impl AsRef<Path>) -> Result<(), Error> {
     let data = dc_read_file(context, filename)?;
 
-    unsafe { dc_receive_imf(context, &data, "import", 0, 0) };
+    dc_receive_imf(context, &data, "import", 0, 0);
     Ok(())
 }
 
@@ -107,18 +106,19 @@ fn dc_poke_eml_file(context: &Context, filename: impl AsRef<Path>) -> Result<(),
 /// @param context The context as created by dc_context_new().
 /// @param spec The file or directory to import. NULL for the last command.
 /// @return 1=success, 0=error.
-fn poke_spec(context: &Context, spec: *const libc::c_char) -> libc::c_int {
+fn poke_spec(context: &Context, spec: Option<&str>) -> libc::c_int {
     if !context.sql.is_open() {
         error!(context, "Import: Database not opened.");
         return 0;
     }
 
-    let real_spec: String;
     let mut read_cnt = 0;
 
+    let real_spec: String;
+
     /* if `spec` is given, remember it for later usage; if it is not given, try to use the last one */
-    if !spec.is_null() {
-        real_spec = to_string_lossy(spec);
+    if let Some(spec) = spec {
+        real_spec = spec.to_string();
         context
             .sql
             .set_raw_config(context, "import_spec", Some(&real_spec))
@@ -174,7 +174,7 @@ fn poke_spec(context: &Context, spec: *const libc::c_char) -> libc::c_int {
     1
 }
 
-unsafe fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
+fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
     let contact = Contact::get_by_id(context, msg.get_from_id()).expect("invalid contact");
     let contact_name = contact.get_name();
     let contact_id = contact.get_id();
@@ -219,7 +219,7 @@ unsafe fn log_msg(context: &Context, prefix: impl AsRef<str>, msg: &Message) {
     );
 }
 
-unsafe fn log_msglist(context: &Context, msglist: &Vec<MsgId>) -> Result<(), Error> {
+fn log_msglist(context: &Context, msglist: &Vec<MsgId>) -> Result<(), Error> {
     let mut lines_out = 0;
     for &msg_id in msglist {
         if msg_id.is_daymarker() {
@@ -250,7 +250,7 @@ unsafe fn log_msglist(context: &Context, msglist: &Vec<MsgId>) -> Result<(), Err
     Ok(())
 }
 
-unsafe fn log_contactlist(context: &Context, contacts: &Vec<u32>) {
+fn log_contactlist(context: &Context, contacts: &Vec<u32>) {
     let mut contacts = contacts.clone();
     if !contacts.contains(&1) {
         contacts.push(1);
@@ -302,7 +302,7 @@ fn chat_prefix(chat: &Chat) -> &'static str {
     chat.typ.into()
 }
 
-pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::Error> {
+pub fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::Error> {
     let chat_id = *context.cmdline_sel_chat_id.read().unwrap();
     let mut sel_chat = if chat_id > 0 {
         Chat::load_from_db(context, chat_id).ok()
@@ -313,11 +313,6 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
     let mut args = line.splitn(3, ' ');
     let arg0 = args.next().unwrap_or_default();
     let arg1 = args.next().unwrap_or_default();
-    let arg1_c = if arg1.is_empty() {
-        std::ptr::null()
-    } else {
-        arg1.strdup() as *const _
-    };
     let arg2 = args.next().unwrap_or_default();
 
     let blobdir = context.get_blobdir();
@@ -467,7 +462,7 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
             );
         }
         "poke" => {
-            ensure!(0 != poke_spec(context, arg1_c), "Poke failed");
+            ensure!(0 != poke_spec(context, Some(arg1)), "Poke failed");
         }
         "reset" => {
             ensure!(!arg1.is_empty(), "Argument <bits> missing: 1=jobs, 2=peerstates, 4=private keys, 8=rest but server config");
@@ -837,6 +832,9 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
             msg.set_text(Some(arg1.to_string()));
             chat::add_device_msg(context, None, Some(&mut msg))?;
         }
+        "updatedevicechats" => {
+            context.update_device_chats()?;
+        }
         "listmedia" => {
             ensure!(sel_chat.is_some(), "No chat selected.");
 
@@ -1005,7 +1003,5 @@ pub unsafe fn dc_cmdline(context: &Context, line: &str) -> Result<(), failure::E
         _ => bail!("Unknown command: \"{}\" type ? for help.", arg0),
     }
 
-    free(arg1_c as *mut _);
-
     Ok(())
 }

examples/repl/main.rs

@@ -366,12 +366,11 @@ fn main_0(args: Vec<String>) -> Result<(), failure::Error> {
         println!("Error: Bad arguments, expected [db-name].");
         return Err(format_err!("No db-name specified"));
     }
-    let context = ContextBuilder::new(
+    let context = Context::new(
         Box::new(receive_event),
         "CLI".into(),
         Path::new(&args[1]).to_path_buf(),
-    )
-    .create()?;
+    )?;
 
     println!("Delta Chat Core is awaiting your commands.");
 
@@ -404,7 +403,7 @@ fn main_0(args: Vec<String>) -> Result<(), failure::Error> {
                 // TODO: ignore "set mail_pw"
                 rl.add_history_entry(line.as_str());
                 let ctx = ctx.clone();
-                match unsafe { handle_cmd(line.trim(), ctx) } {
+                match handle_cmd(line.trim(), ctx) {
                     Ok(ExitResult::Continue) => {}
                     Ok(ExitResult::Exit) => break,
                     Err(err) => println!("Error: {}", err),
@@ -435,7 +434,7 @@ enum ExitResult {
     Exit,
 }
 
-unsafe fn handle_cmd(line: &str, ctx: Arc<RwLock<Context>>) -> Result<ExitResult, failure::Error> {
+fn handle_cmd(line: &str, ctx: Arc<RwLock<Context>>) -> Result<ExitResult, failure::Error> {
     let mut args = line.splitn(2, ' ');
     let arg0 = args.next().unwrap_or_default();
     let arg1 = args.next().unwrap_or_default();

examples/simple.rs

@@ -39,9 +39,8 @@ fn main() {
     let dir = tempdir().unwrap();
     let dbfile = dir.path().join("db.sqlite");
     println!("creating database {:?}", dbfile);
-    let ctx = ContextBuilder::new(Box::new(cb), "FakeOs".into(), dbfile)
-        .create()
-        .expect("Failed to create context");
+    let ctx =
+        Context::new(Box::new(cb), "FakeOs".into(), dbfile).expect("Failed to create context");
     let running = Arc::new(RwLock::new(true));
     let info = ctx.get_info();
     let duration = time::Duration::from_millis(4000);
@@ -102,16 +101,6 @@ fn main() {
 
     thread::sleep(duration);
 
-    // let msglist = dc_get_chat_msgs(&ctx, chat_id, 0, 0);
-    // for i in 0..dc_array_get_cnt(msglist) {
-    //     let msg_id = dc_array_get_id(msglist, i);
-    //     let msg = dc_get_msg(context, msg_id);
-    //     let text = CStr::from_ptr(dc_msg_get_text(msg)).unwrap();
-    //     println!("Message {}: {}\n", i + 1, text.to_str().unwrap());
-    //     dc_msg_unref(msg);
-    // }
-    // dc_array_unref(msglist);
-
     println!("stopping threads");
 
     *running.write().unwrap() = false;

mmime/.circleci/config.yml

@@ -1,42 +0,0 @@
-# copied from http://koushiro.me/2019/04/30/Building-and-Testing-Rust-projects-on-CircleCI/
-
-version: 2.1
-jobs:
-  build:
-    docker:
-      - image: ubuntu:18.04
-
-    working_directory: ~/deltachat-core-rust
-
-    steps:
-      - checkout
-
-      - run:
-          name: Setup build environment
-          command: |
-            apt update
-            apt install -y curl build-essential autoconf libtool git python pkg-config
-            # this will pick default toolchain from `rust-toolchain` file
-            curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- --no-modify-path --default-toolchain none -y;
-            source $HOME/.cargo/env
-          no_output_timeout: 1800s
-
-      - run:
-          name: Format
-          command: |
-            export PATH=~/.cargo/bin:$PATH
-            rustup component add rustfmt
-            cargo fmt -- --check
-
-      - run:
-          name: Test
-          command: |
-            export PATH=~/.cargo/bin:$PATH
-            export RUST_BACKTRACE=1
-            cargo test
-
-workflows:
-  version: 2.1
-  build:
-    jobs:
-      - build

mmime/Cargo.toml

@@ -1,23 +0,0 @@
-[package]
-name = "mmime"
-version = "0.1.2"
-authors = ["dignifiedquire <dignifiedquire@users.noreply.github.com>"]
-edition = "2018"
-license = "MIT OR Apache-2.0"
-homepage = "https://github.com/deltachat/deltachat-core-rust"
-repository = "https://github.com/deltachat/deltachat-core-rust"
-readme = "README.md"
-description = "Mime parsing for email"
-
-
-keywords = ["mail", "mim", "email", "imap", "smtp"]
-categories = ["std", "email"]
-
-[dependencies]
-libc = "0.2.54"
-charset = "0.1.2"
-memmap = "0.7.0"
-lazy_static = "1.3.0"
-rand = "0.6.5"
-chrono = "0.4.6"
-hex = "0.4.0"

mmime/LICENSE-APACHE

@@ -1,201 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.

mmime/LICENSE-MIT

@@ -1,23 +0,0 @@
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.

mmime/LICENSE.md

@@ -1,4 +0,0 @@
-This library is primarly distributed under the terms of both the MIT license and
-the Apache License (Version 2.0).
-
-See LICENSE-MIT and LICENSE-APACHE for details.

mmime/README.md

@@ -1,16 +0,0 @@
-# mmime
-
-[![CircleCI build status][circle-shield]][circle] [![Appveyor build status][appveyor-shield]][appveyor] [![License][license-shield]][license]
-
-> mmmmmmime parsing
-
-Base code was compiled using c2rust from libetpan.
-
-
-
-[circle-shield]: https://img.shields.io/circleci/project/github/dignifiedquire/mmime/master.svg?style=flat-square
-[circle]: https://circleci.com/gh/dignifiedquire/mmime/
-[appveyor-shield]: https://ci.appveyor.com/api/projects/status/l26co5rba32knrlu/branch/master?style=flat-square
-[appveyor]: https://ci.appveyor.com/project/dignifiedquire/mmime/branch/master
-[license-shield]: https://img.shields.io/badge/License-MIT%2FApache2.0-green.svg?style=flat-square
-[license]: https://github.com/rpgp/rpgp/blob/master/LICENSE.md

mmime/src/charconv.rs

@@ -1,32 +0,0 @@
-use crate::other::*;
-use libc;
-use std::ffi::{CStr, CString};
-
-pub const MAIL_CHARCONV_ERROR_CONV: libc::c_uint = 3;
-pub const MAIL_CHARCONV_ERROR_MEMORY: libc::c_uint = 2;
-pub const MAIL_CHARCONV_ERROR_UNKNOWN_CHARSET: libc::c_uint = 1;
-pub const MAIL_CHARCONV_NO_ERROR: libc::c_uint = 0;
-
-pub unsafe fn charconv(
-    tocode: *const libc::c_char,
-    fromcode: *const libc::c_char,
-    s: *const libc::c_char,
-    length: size_t,
-    result: *mut *mut libc::c_char,
-) -> libc::c_int {
-    assert!(!fromcode.is_null(), "invalid fromcode");
-    assert!(!s.is_null(), "invalid input string");
-    if let Some(encoding) =
-        charset::Charset::for_label(CStr::from_ptr(fromcode).to_string_lossy().as_bytes())
-    {
-        let data = std::slice::from_raw_parts(s as *const u8, strlen(s));
-
-        let (res, _, _) = encoding.decode(data);
-        let res_c = CString::new(res.as_bytes()).unwrap_or_default();
-        *result = strdup(res_c.as_ptr()) as *mut _;
-
-        MAIL_CHARCONV_NO_ERROR as libc::c_int
-    } else {
-        MAIL_CHARCONV_ERROR_UNKNOWN_CHARSET as libc::c_int
-    }
-}

mmime/src/chash.rs

@@ -1,427 +0,0 @@
-use libc;
-
-use crate::other::*;
-
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct chashdatum {
-    pub data: *mut libc::c_void,
-    pub len: libc::c_uint,
-}
-
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct chash {
-    pub size: libc::c_uint,
-    pub count: libc::c_uint,
-    pub copyvalue: libc::c_int,
-    pub copykey: libc::c_int,
-    pub cells: *mut *mut chashcell,
-}
-
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct chashcell {
-    pub func: libc::c_uint,
-    pub key: chashdatum,
-    pub value: chashdatum,
-    pub next: *mut chashcell,
-}
-
-pub type chashiter = chashcell;
-/* Allocates a new (empty) hash using this initial size and the given flags,
-  specifying which data should be copied in the hash.
-   CHASH_COPYNONE  : Keys/Values are not copied.
-   CHASH_COPYKEY   : Keys are dupped and freed as needed in the hash.
-   CHASH_COPYVALUE : Values are dupped and freed as needed in the hash.
-   CHASH_COPYALL   : Both keys and values are dupped in the hash.
-*/
-pub unsafe fn chash_new(mut size: libc::c_uint, mut flags: libc::c_int) -> *mut chash {
-    let mut h: *mut chash = 0 as *mut chash;
-    h = malloc(::std::mem::size_of::<chash>() as libc::size_t) as *mut chash;
-    if h.is_null() {
-        return 0 as *mut chash;
-    }
-    if size < 13i32 as libc::c_uint {
-        size = 13i32 as libc::c_uint
-    }
-    (*h).count = 0i32 as libc::c_uint;
-    (*h).cells = calloc(
-        size as libc::size_t,
-        ::std::mem::size_of::<*mut chashcell>() as libc::size_t,
-    ) as *mut *mut chashcell;
-    if (*h).cells.is_null() {
-        free(h as *mut libc::c_void);
-        return 0 as *mut chash;
-    }
-    (*h).size = size;
-    (*h).copykey = flags & 1i32;
-    (*h).copyvalue = flags & 2i32;
-    return h;
-}
-
-/* Frees a hash */
-pub unsafe fn chash_free(mut hash: *mut chash) {
-    let mut indx: libc::c_uint = 0;
-    let mut iter: *mut chashiter = 0 as *mut chashiter;
-    let mut next: *mut chashiter = 0 as *mut chashiter;
-    indx = 0i32 as libc::c_uint;
-    while indx < (*hash).size {
-        iter = *(*hash).cells.offset(indx as isize);
-        while !iter.is_null() {
-            next = (*iter).next;
-            if 0 != (*hash).copykey {
-                free((*iter).key.data);
-            }
-            if 0 != (*hash).copyvalue {
-                free((*iter).value.data);
-            }
-            free(iter as *mut libc::c_void);
-            iter = next
-        }
-        indx = indx.wrapping_add(1)
-    }
-    free((*hash).cells as *mut libc::c_void);
-    free(hash as *mut libc::c_void);
-}
-
-/* Removes all elements from a hash */
-pub unsafe fn chash_clear(mut hash: *mut chash) {
-    let mut indx: libc::c_uint = 0;
-    let mut iter: *mut chashiter = 0 as *mut chashiter;
-    let mut next: *mut chashiter = 0 as *mut chashiter;
-    indx = 0i32 as libc::c_uint;
-    while indx < (*hash).size {
-        iter = *(*hash).cells.offset(indx as isize);
-        while !iter.is_null() {
-            next = (*iter).next;
-            if 0 != (*hash).copykey {
-                free((*iter).key.data);
-            }
-            if 0 != (*hash).copyvalue {
-                free((*iter).value.data);
-            }
-            free(iter as *mut libc::c_void);
-            iter = next
-        }
-        indx = indx.wrapping_add(1)
-    }
-    memset(
-        (*hash).cells as *mut libc::c_void,
-        0i32,
-        ((*hash).size as libc::size_t)
-            .wrapping_mul(::std::mem::size_of::<*mut chashcell>() as libc::size_t),
-    );
-    (*hash).count = 0i32 as libc::c_uint;
-}
-/* Adds an entry in the hash table.
-Length can be 0 if key/value are strings.
-If an entry already exists for this key, it is replaced, and its value
-is returned. Otherwise, the data pointer will be NULL and the length
-field be set to TRUE or FALSe to indicate success or failure. */
-pub unsafe fn chash_set(
-    mut hash: *mut chash,
-    mut key: *mut chashdatum,
-    mut value: *mut chashdatum,
-    mut oldvalue: *mut chashdatum,
-) -> libc::c_int {
-    let mut current_block: u64;
-    let mut func: libc::c_uint = 0;
-    let mut indx: libc::c_uint = 0;
-    let mut iter: *mut chashiter = 0 as *mut chashiter;
-    let mut cell: *mut chashiter = 0 as *mut chashiter;
-    let mut r: libc::c_int = 0;
-    if (*hash).count > (*hash).size.wrapping_mul(3i32 as libc::c_uint) {
-        r = chash_resize(
-            hash,
-            (*hash)
-                .count
-                .wrapping_div(3i32 as libc::c_uint)
-                .wrapping_mul(2i32 as libc::c_uint)
-                .wrapping_add(1i32 as libc::c_uint),
-        );
-        if r < 0i32 {
-            current_block = 17701753836843438419;
-        } else {
-            current_block = 7095457783677275021;
-        }
-    } else {
-        current_block = 7095457783677275021;
-    }
-    match current_block {
-        7095457783677275021 => {
-            func = chash_func((*key).data as *const libc::c_char, (*key).len);
-            indx = func.wrapping_rem((*hash).size);
-            iter = *(*hash).cells.offset(indx as isize);
-            loop {
-                if iter.is_null() {
-                    current_block = 17788412896529399552;
-                    break;
-                }
-                if (*iter).key.len == (*key).len
-                    && (*iter).func == func
-                    && 0 == memcmp((*iter).key.data, (*key).data, (*key).len as libc::size_t)
-                {
-                    /* found, replacing entry */
-                    if 0 != (*hash).copyvalue {
-                        let mut data: *mut libc::c_char = 0 as *mut libc::c_char;
-                        data = chash_dup((*value).data, (*value).len);
-                        if data.is_null() {
-                            current_block = 17701753836843438419;
-                            break;
-                        }
-                        free((*iter).value.data);
-                        (*iter).value.data = data as *mut libc::c_void;
-                        (*iter).value.len = (*value).len
-                    } else {
-                        if !oldvalue.is_null() {
-                            (*oldvalue).data = (*iter).value.data;
-                            (*oldvalue).len = (*iter).value.len
-                        }
-                        (*iter).value.data = (*value).data;
-                        (*iter).value.len = (*value).len
-                    }
-                    if 0 == (*hash).copykey {
-                        (*iter).key.data = (*key).data
-                    }
-                    if !oldvalue.is_null() {
-                        (*oldvalue).data = (*value).data;
-                        (*oldvalue).len = (*value).len
-                    }
-                    return 0i32;
-                } else {
-                    iter = (*iter).next
-                }
-            }
-            match current_block {
-                17701753836843438419 => {}
-                _ => {
-                    if !oldvalue.is_null() {
-                        (*oldvalue).data = 0 as *mut libc::c_void;
-                        (*oldvalue).len = 0i32 as libc::c_uint
-                    }
-                    cell = malloc(::std::mem::size_of::<chashcell>() as libc::size_t)
-                        as *mut chashcell;
-                    if !cell.is_null() {
-                        if 0 != (*hash).copykey {
-                            (*cell).key.data =
-                                chash_dup((*key).data, (*key).len) as *mut libc::c_void;
-                            if (*cell).key.data.is_null() {
-                                current_block = 4267898785354516004;
-                            } else {
-                                current_block = 7226443171521532240;
-                            }
-                        } else {
-                            (*cell).key.data = (*key).data;
-                            current_block = 7226443171521532240;
-                        }
-                        match current_block {
-                            7226443171521532240 => {
-                                (*cell).key.len = (*key).len;
-                                if 0 != (*hash).copyvalue {
-                                    (*cell).value.data =
-                                        chash_dup((*value).data, (*value).len) as *mut libc::c_void;
-                                    if (*cell).value.data.is_null() {
-                                        if 0 != (*hash).copykey {
-                                            free((*cell).key.data);
-                                        }
-                                        current_block = 4267898785354516004;
-                                    } else {
-                                        current_block = 6717214610478484138;
-                                    }
-                                } else {
-                                    (*cell).value.data = (*value).data;
-                                    current_block = 6717214610478484138;
-                                }
-                                match current_block {
-                                    4267898785354516004 => {}
-                                    _ => {
-                                        (*cell).value.len = (*value).len;
-                                        (*cell).func = func;
-                                        (*cell).next = *(*hash).cells.offset(indx as isize);
-                                        let ref mut fresh0 = *(*hash).cells.offset(indx as isize);
-                                        *fresh0 = cell;
-                                        (*hash).count = (*hash).count.wrapping_add(1);
-                                        return 0i32;
-                                    }
-                                }
-                            }
-                            _ => {}
-                        }
-                        free(cell as *mut libc::c_void);
-                    }
-                }
-            }
-        }
-        _ => {}
-    }
-    return -1i32;
-}
-#[inline]
-unsafe fn chash_dup(mut data: *const libc::c_void, mut len: libc::c_uint) -> *mut libc::c_char {
-    let mut r: *mut libc::c_void = 0 as *mut libc::c_void;
-    r = malloc(len as libc::size_t) as *mut libc::c_char as *mut libc::c_void;
-    if r.is_null() {
-        return 0 as *mut libc::c_char;
-    }
-    memcpy(r, data, len as libc::size_t);
-    return r as *mut libc::c_char;
-}
-
-#[inline]
-unsafe fn chash_func(mut key: *const libc::c_char, mut len: libc::c_uint) -> libc::c_uint {
-    let mut c: libc::c_uint = 5381i32 as libc::c_uint;
-    let mut k: *const libc::c_char = key;
-    loop {
-        let fresh1 = len;
-        len = len.wrapping_sub(1);
-        if !(0 != fresh1) {
-            break;
-        }
-        let fresh2 = k;
-        k = k.offset(1);
-        c = (c << 5i32)
-            .wrapping_add(c)
-            .wrapping_add(*fresh2 as libc::c_uint)
-    }
-    return c;
-}
-
-/* Resizes the hash table to the passed size. */
-pub unsafe fn chash_resize(mut hash: *mut chash, mut size: libc::c_uint) -> libc::c_int {
-    let mut cells: *mut *mut chashcell = 0 as *mut *mut chashcell;
-    let mut indx: libc::c_uint = 0;
-    let mut nindx: libc::c_uint = 0;
-    let mut iter: *mut chashiter = 0 as *mut chashiter;
-    let mut next: *mut chashiter = 0 as *mut chashiter;
-    if (*hash).size == size {
-        return 0i32;
-    }
-    cells = calloc(
-        size as libc::size_t,
-        ::std::mem::size_of::<*mut chashcell>() as libc::size_t,
-    ) as *mut *mut chashcell;
-    if cells.is_null() {
-        return -1i32;
-    }
-    indx = 0i32 as libc::c_uint;
-    while indx < (*hash).size {
-        iter = *(*hash).cells.offset(indx as isize);
-        while !iter.is_null() {
-            next = (*iter).next;
-            nindx = (*iter).func.wrapping_rem(size);
-            (*iter).next = *cells.offset(nindx as isize);
-            let ref mut fresh3 = *cells.offset(nindx as isize);
-            *fresh3 = iter;
-            iter = next
-        }
-        indx = indx.wrapping_add(1)
-    }
-    free((*hash).cells as *mut libc::c_void);
-    (*hash).size = size;
-    (*hash).cells = cells;
-    return 0i32;
-}
-
-/* Retrieves the data associated to the key if it is found in the hash table.
-The data pointer and the length will be NULL if not found*/
-pub unsafe fn chash_get(
-    mut hash: *mut chash,
-    mut key: *mut chashdatum,
-    mut result: *mut chashdatum,
-) -> libc::c_int {
-    let mut func: libc::c_uint = 0;
-    let mut iter: *mut chashiter = 0 as *mut chashiter;
-    func = chash_func((*key).data as *const libc::c_char, (*key).len);
-    iter = *(*hash)
-        .cells
-        .offset(func.wrapping_rem((*hash).size) as isize);
-    while !iter.is_null() {
-        if (*iter).key.len == (*key).len
-            && (*iter).func == func
-            && 0 == memcmp((*iter).key.data, (*key).data, (*key).len as libc::size_t)
-        {
-            *result = (*iter).value;
-            return 0i32;
-        }
-        iter = (*iter).next
-    }
-    return -1i32;
-}
-/* Removes the entry associated to this key if it is found in the hash table,
-and returns its contents if not dupped (otherwise, pointer will be NULL
-and len TRUE). If entry is not found both pointer and len will be NULL. */
-pub unsafe fn chash_delete(
-    mut hash: *mut chash,
-    mut key: *mut chashdatum,
-    mut oldvalue: *mut chashdatum,
-) -> libc::c_int {
-    /*  chashdatum result = { NULL, TRUE }; */
-    let mut func: libc::c_uint = 0;
-    let mut indx: libc::c_uint = 0;
-    let mut iter: *mut chashiter = 0 as *mut chashiter;
-    let mut old: *mut chashiter = 0 as *mut chashiter;
-    func = chash_func((*key).data as *const libc::c_char, (*key).len);
-    indx = func.wrapping_rem((*hash).size);
-    old = 0 as *mut chashiter;
-    iter = *(*hash).cells.offset(indx as isize);
-    while !iter.is_null() {
-        if (*iter).key.len == (*key).len
-            && (*iter).func == func
-            && 0 == memcmp((*iter).key.data, (*key).data, (*key).len as libc::size_t)
-        {
-            if !old.is_null() {
-                (*old).next = (*iter).next
-            } else {
-                let ref mut fresh4 = *(*hash).cells.offset(indx as isize);
-                *fresh4 = (*iter).next
-            }
-            if 0 != (*hash).copykey {
-                free((*iter).key.data);
-            }
-            if 0 != (*hash).copyvalue {
-                free((*iter).value.data);
-            } else if !oldvalue.is_null() {
-                (*oldvalue).data = (*iter).value.data;
-                (*oldvalue).len = (*iter).value.len
-            }
-            free(iter as *mut libc::c_void);
-            (*hash).count = (*hash).count.wrapping_sub(1);
-            return 0i32;
-        }
-        old = iter;
-        iter = (*iter).next
-    }
-    return -1i32;
-}
-/* Returns an iterator to the first non-empty entry of the hash table */
-pub unsafe fn chash_begin(mut hash: *mut chash) -> *mut chashiter {
-    let mut iter: *mut chashiter = 0 as *mut chashiter;
-    let mut indx: libc::c_uint = 0i32 as libc::c_uint;
-    iter = *(*hash).cells.offset(0isize);
-    while iter.is_null() {
-        indx = indx.wrapping_add(1);
-        if indx >= (*hash).size {
-            return 0 as *mut chashiter;
-        }
-        iter = *(*hash).cells.offset(indx as isize)
-    }
-    return iter;
-}
-/* Returns the next non-empty entry of the hash table */
-pub unsafe fn chash_next(mut hash: *mut chash, mut iter: *mut chashiter) -> *mut chashiter {
-    let mut indx: libc::c_uint = 0;
-    if iter.is_null() {
-        return 0 as *mut chashiter;
-    }
-    indx = (*iter).func.wrapping_rem((*hash).size);
-    iter = (*iter).next;
-    while iter.is_null() {
-        indx = indx.wrapping_add(1);
-        if indx >= (*hash).size {
-            return 0 as *mut chashiter;
-        }
-        iter = *(*hash).cells.offset(indx as isize)
-    }
-    return iter;
-}

mmime/src/clist.rs

@@ -1,202 +0,0 @@
-use libc;
-
-use crate::other::*;
-
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct clistcell {
-    pub data: *mut libc::c_void,
-    pub previous: *mut clistcell,
-    pub next: *mut clistcell,
-}
-
-#[derive(Clone)]
-#[repr(C)]
-pub struct clist {
-    pub first: *mut clistcell,
-    pub last: *mut clistcell,
-    pub count: libc::c_int,
-}
-
-impl Default for clist {
-    fn default() -> Self {
-        Self {
-            first: std::ptr::null_mut(),
-            last: std::ptr::null_mut(),
-            count: 0,
-        }
-    }
-}
-
-impl Drop for clist {
-    fn drop(&mut self) {
-        unsafe {
-            let mut l1 = self.first;
-            while !l1.is_null() {
-                let l2 = (*l1).next;
-                free(l1 as *mut libc::c_void);
-                l1 = l2
-            }
-        }
-    }
-}
-
-pub type clistiter = clistcell;
-pub struct CListIterator {
-    cur: *mut clistiter,
-}
-impl Iterator for CListIterator {
-    type Item = *mut libc::c_void;
-    fn next(&mut self) -> Option<Self::Item> {
-        unsafe {
-            if self.cur.is_null() {
-                None
-            } else {
-                let data = (*self.cur).data;
-                self.cur = (*self.cur).next;
-                Some(data)
-            }
-        }
-    }
-}
-
-impl IntoIterator for &clist {
-    type Item = *mut libc::c_void;
-    type IntoIter = CListIterator;
-    fn into_iter(self) -> Self::IntoIter {
-        return CListIterator { cur: self.first };
-    }
-}
-
-pub type clist_func =
-    Option<unsafe extern "C" fn(_: *mut libc::c_void, _: *mut libc::c_void) -> ()>;
-
-/* Allocate a new pointer list */
-pub fn clist_new() -> *mut clist {
-    Box::into_raw(Box::new(Default::default()))
-}
-/* Destroys a list. Data pointed by data pointers is NOT freed. */
-pub unsafe fn clist_free(mut lst: *mut clist) {
-    Box::from_raw(lst);
-}
-/* Inserts this data pointer after the element pointed by the iterator */
-pub unsafe fn clist_insert_after(
-    mut lst: *mut clist,
-    mut iter: *mut clistiter,
-    mut data: *mut libc::c_void,
-) -> libc::c_int {
-    let mut c: *mut clistcell = 0 as *mut clistcell;
-    c = malloc(::std::mem::size_of::<clistcell>() as libc::size_t) as *mut clistcell;
-    if c.is_null() {
-        return -1i32;
-    }
-    (*c).data = data;
-    (*lst).count += 1;
-    if (*lst).first == (*lst).last && (*lst).last.is_null() {
-        (*c).next = 0 as *mut clistcell;
-        (*c).previous = (*c).next;
-        (*lst).last = c;
-        (*lst).first = (*lst).last;
-        return 0i32;
-    }
-    if iter.is_null() {
-        (*c).previous = (*lst).last;
-        (*(*c).previous).next = c;
-        (*c).next = 0 as *mut clistcell;
-        (*lst).last = c;
-        return 0i32;
-    }
-    (*c).previous = iter;
-    (*c).next = (*iter).next;
-    if !(*c).next.is_null() {
-        (*(*c).next).previous = c
-    } else {
-        (*lst).last = c
-    }
-    (*(*c).previous).next = c;
-    return 0i32;
-}
-/* Deletes the element pointed by the iterator.
-Returns an iterator to the next element. */
-pub unsafe fn clist_delete(mut lst: *mut clist, mut iter: *mut clistiter) -> *mut clistiter {
-    let mut ret: *mut clistiter = 0 as *mut clistiter;
-    if iter.is_null() {
-        return 0 as *mut clistiter;
-    }
-    if !(*iter).previous.is_null() {
-        (*(*iter).previous).next = (*iter).next
-    } else {
-        (*lst).first = (*iter).next
-    }
-    if !(*iter).next.is_null() {
-        (*(*iter).next).previous = (*iter).previous;
-        ret = (*iter).next
-    } else {
-        (*lst).last = (*iter).previous;
-        ret = 0 as *mut clistiter
-    }
-    free(iter as *mut libc::c_void);
-    (*lst).count -= 1;
-    return ret;
-}
-pub unsafe fn clist_foreach(
-    mut lst: *mut clist,
-    mut func: clist_func,
-    mut data: *mut libc::c_void,
-) {
-    let mut cur: *mut clistiter = 0 as *mut clistiter;
-    cur = (*lst).first;
-    while !cur.is_null() {
-        func.expect("non-null function pointer")((*cur).data, data);
-        cur = (*cur).next
-    }
-}
-
-pub unsafe fn clist_nth_data(mut lst: *mut clist, mut indx: libc::c_int) -> *mut libc::c_void {
-    let mut cur: *mut clistiter = 0 as *mut clistiter;
-    cur = internal_clist_nth(lst, indx);
-    if cur.is_null() {
-        return 0 as *mut libc::c_void;
-    }
-    return (*cur).data;
-}
-#[inline]
-unsafe fn internal_clist_nth(mut lst: *mut clist, mut indx: libc::c_int) -> *mut clistiter {
-    let mut cur: *mut clistiter = 0 as *mut clistiter;
-    cur = (*lst).first;
-    while indx > 0i32 && !cur.is_null() {
-        cur = (*cur).next;
-        indx -= 1
-    }
-    if cur.is_null() {
-        return 0 as *mut clistiter;
-    }
-    return cur;
-}
-
-pub unsafe fn clist_nth(mut lst: *mut clist, mut indx: libc::c_int) -> *mut clistiter {
-    return internal_clist_nth(lst, indx);
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::ptr;
-    #[test]
-    fn test_clist_iterator() {
-        unsafe {
-            let mut c = clist_new();
-            assert!(!c.is_null());
-            clist_insert_after(c, ptr::null_mut(), clist_nth as _);
-            assert_eq!((*c).count, 1);
-
-            /* Only one iteration */
-            for data in &*c {
-                assert_eq!(data, clist_nth as _);
-            }
-            assert_eq!((*c).count, 1);
-
-            clist_free(c);
-        }
-    }
-}

mmime/src/constants.rs

@@ -1,71 +0,0 @@
-pub const MAIL_ERROR_SSL: libc::c_uint = 58;
-pub const MAIL_ERROR_FOLDER: libc::c_uint = 57;
-pub const MAIL_ERROR_UNABLE: libc::c_uint = 56;
-pub const MAIL_ERROR_SYSTEM: libc::c_uint = 55;
-pub const MAIL_ERROR_COMMAND: libc::c_uint = 54;
-pub const MAIL_ERROR_SEND: libc::c_uint = 53;
-pub const MAIL_ERROR_CHAR_ENCODING_FAILED: libc::c_uint = 52;
-pub const MAIL_ERROR_SUBJECT_NOT_FOUND: libc::c_uint = 51;
-/* 50 */
-pub const MAIL_ERROR_PROGRAM_ERROR: libc::c_uint = 50;
-pub const MAIL_ERROR_NO_PERMISSION: libc::c_uint = 49;
-pub const MAIL_ERROR_COMMAND_NOT_SUPPORTED: libc::c_uint = 48;
-pub const MAIL_ERROR_NO_APOP: libc::c_uint = 47;
-pub const MAIL_ERROR_READONLY: libc::c_uint = 46;
-pub const MAIL_ERROR_FATAL: libc::c_uint = 45;
-pub const MAIL_ERROR_CLOSE: libc::c_uint = 44;
-pub const MAIL_ERROR_CAPABILITY: libc::c_uint = 43;
-pub const MAIL_ERROR_PROTOCOL: libc::c_uint = 42;
-/* misc errors */
-pub const MAIL_ERROR_MISC: libc::c_uint = 41;
-/* 40 */
-pub const MAIL_ERROR_EXPUNGE: libc::c_uint = 40;
-pub const MAIL_ERROR_NO_TLS: libc::c_uint = 39;
-pub const MAIL_ERROR_CACHE_MISS: libc::c_uint = 38;
-pub const MAIL_ERROR_STARTTLS: libc::c_uint = 37;
-pub const MAIL_ERROR_MOVE: libc::c_uint = 36;
-pub const MAIL_ERROR_FOLDER_NOT_FOUND: libc::c_uint = 35;
-pub const MAIL_ERROR_REMOVE: libc::c_uint = 34;
-pub const MAIL_ERROR_PART_NOT_FOUND: libc::c_uint = 33;
-pub const MAIL_ERROR_INVAL: libc::c_uint = 32;
-pub const MAIL_ERROR_PARSE: libc::c_uint = 31;
-/* 30 */
-pub const MAIL_ERROR_MSG_NOT_FOUND: libc::c_uint = 30;
-pub const MAIL_ERROR_DISKSPACE: libc::c_uint = 29;
-pub const MAIL_ERROR_SEARCH: libc::c_uint = 28;
-pub const MAIL_ERROR_STORE: libc::c_uint = 27;
-pub const MAIL_ERROR_FETCH: libc::c_uint = 26;
-pub const MAIL_ERROR_COPY: libc::c_uint = 25;
-pub const MAIL_ERROR_APPEND: libc::c_uint = 24;
-pub const MAIL_ERROR_LSUB: libc::c_uint = 23;
-pub const MAIL_ERROR_LIST: libc::c_uint = 22;
-pub const MAIL_ERROR_UNSUBSCRIBE: libc::c_uint = 21;
-/* 20 */
-pub const MAIL_ERROR_SUBSCRIBE: libc::c_uint = 20;
-pub const MAIL_ERROR_STATUS: libc::c_uint = 19;
-pub const MAIL_ERROR_MEMORY: libc::c_uint = 18;
-pub const MAIL_ERROR_SELECT: libc::c_uint = 17;
-pub const MAIL_ERROR_EXAMINE: libc::c_uint = 16;
-pub const MAIL_ERROR_CHECK: libc::c_uint = 15;
-pub const MAIL_ERROR_RENAME: libc::c_uint = 14;
-pub const MAIL_ERROR_NOOP: libc::c_uint = 13;
-pub const MAIL_ERROR_LOGOUT: libc::c_uint = 12;
-pub const MAIL_ERROR_DELETE: libc::c_uint = 11;
-/* 10 */
-pub const MAIL_ERROR_CREATE: libc::c_uint = 10;
-pub const MAIL_ERROR_LOGIN: libc::c_uint = 9;
-pub const MAIL_ERROR_STREAM: libc::c_uint = 8;
-pub const MAIL_ERROR_FILE: libc::c_uint = 7;
-pub const MAIL_ERROR_BAD_STATE: libc::c_uint = 6;
-pub const MAIL_ERROR_CONNECT: libc::c_uint = 5;
-pub const MAIL_ERROR_UNKNOWN: libc::c_uint = 4;
-pub const MAIL_ERROR_NOT_IMPLEMENTED: libc::c_uint = 3;
-pub const MAIL_NO_ERROR_NON_AUTHENTICATED: libc::c_uint = 2;
-pub const MAIL_NO_ERROR_AUTHENTICATED: libc::c_uint = 1;
-pub const MAIL_NO_ERROR: libc::c_uint = 0;
-
-pub const MAILIMF_ERROR_FILE: libc::c_uint = 4;
-pub const MAILIMF_ERROR_INVAL: libc::c_uint = 3;
-pub const MAILIMF_ERROR_MEMORY: libc::c_uint = 2;
-pub const MAILIMF_ERROR_PARSE: libc::c_uint = 1;
-pub const MAILIMF_NO_ERROR: libc::c_uint = 0;

mmime/src/display.rs

@@ -1,386 +0,0 @@
-use crate::clist::*;
-
-use crate::mailimf::types::*;
-use crate::mailmime::types::*;
-
-use std::ffi::CStr;
-
-pub unsafe fn display_mime(mut mime: *mut Mailmime) {
-    let mut cur: *mut clistiter = 0 as *mut clistiter;
-    println!("{}", (*mime).mm_type);
-
-    match (*mime).mm_type as u32 {
-        MAILMIME_SINGLE => {
-            println!("single part");
-        }
-        MAILMIME_MULTIPLE => {
-            println!("multipart");
-        }
-        MAILMIME_MESSAGE => println!("message"),
-        _ => {}
-    }
-    if !(*mime).mm_mime_fields.is_null() {
-        if !(*(*(*mime).mm_mime_fields).fld_list).first.is_null() {
-            print!("MIME headers begin");
-            display_mime_fields((*mime).mm_mime_fields);
-            println!("MIME headers end");
-        }
-    }
-    display_mime_content((*mime).mm_content_type);
-    match (*mime).mm_type as u32 {
-        MAILMIME_SINGLE => {
-            display_mime_data((*mime).mm_data.mm_single);
-        }
-        MAILMIME_MULTIPLE => {
-            cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first;
-            while !cur.is_null() {
-                display_mime(
-                    (if !cur.is_null() {
-                        (*cur).data
-                    } else {
-                        0 as *mut libc::c_void
-                    }) as *mut Mailmime,
-                );
-                cur = if !cur.is_null() {
-                    (*cur).next
-                } else {
-                    0 as *mut clistcell
-                }
-            }
-        }
-        MAILMIME_MESSAGE => {
-            if !(*mime).mm_data.mm_message.mm_fields.is_null() {
-                if !(*(*(*mime).mm_data.mm_message.mm_fields).fld_list)
-                    .first
-                    .is_null()
-                {
-                    println!("headers begin");
-                    display_fields((*mime).mm_data.mm_message.mm_fields);
-                    println!("headers end");
-                }
-                if !(*mime).mm_data.mm_message.mm_msg_mime.is_null() {
-                    display_mime((*mime).mm_data.mm_message.mm_msg_mime);
-                }
-            }
-        }
-        _ => {}
-    };
-}
-
-unsafe fn display_mime_content(mut content_type: *mut mailmime_content) {
-    print!("type: ");
-    display_mime_type((*content_type).ct_type);
-    println!(
-        "/{}",
-        CStr::from_ptr((*content_type).ct_subtype).to_str().unwrap()
-    );
-}
-unsafe fn display_mime_type(mut type_0: *mut mailmime_type) {
-    match (*type_0).tp_type {
-        1 => {
-            display_mime_discrete_type((*type_0).tp_data.tp_discrete_type);
-        }
-        2 => {
-            display_mime_composite_type((*type_0).tp_data.tp_composite_type);
-        }
-        _ => {}
-    };
-}
-unsafe fn display_mime_composite_type(mut ct: *mut mailmime_composite_type) {
-    match (*ct).ct_type {
-        1 => {
-            print!("message");
-        }
-        2 => {
-            print!("multipart");
-        }
-        3 => {
-            print!("{}", CStr::from_ptr((*ct).ct_token).to_str().unwrap());
-        }
-        _ => {}
-    };
-}
-unsafe fn display_mime_discrete_type(mut discrete_type: *mut mailmime_discrete_type) {
-    match (*discrete_type).dt_type {
-        1 => {
-            print!("text");
-        }
-        2 => {
-            print!("image");
-        }
-        3 => {
-            print!("audio");
-        }
-        4 => {
-            print!("video");
-        }
-        5 => {
-            print!("application");
-        }
-        6 => {
-            print!("{}", (*discrete_type).dt_extension as u8 as char);
-        }
-        _ => {}
-    };
-}
-pub unsafe fn display_mime_data(mut data: *mut mailmime_data) {
-    match (*data).dt_type {
-        0 => {
-            println!(
-                "data : {} bytes",
-                (*data).dt_data.dt_text.dt_length as libc::c_uint,
-            );
-        }
-        1 => {
-            println!(
-                "data (file) : {}",
-                CStr::from_ptr((*data).dt_data.dt_filename)
-                    .to_str()
-                    .unwrap()
-            );
-        }
-        _ => {}
-    };
-}
-unsafe fn display_mime_dsp_parm(mut param: *mut mailmime_disposition_parm) {
-    match (*param).pa_type {
-        0 => {
-            println!(
-                "filename: {}",
-                CStr::from_ptr((*param).pa_data.pa_filename)
-                    .to_str()
-                    .unwrap()
-            );
-        }
-        _ => {}
-    };
-}
-unsafe fn display_mime_disposition(mut disposition: *mut mailmime_disposition) {
-    let mut cur: *mut clistiter = 0 as *mut clistiter;
-    cur = (*(*disposition).dsp_parms).first;
-    while !cur.is_null() {
-        let mut param: *mut mailmime_disposition_parm = 0 as *mut mailmime_disposition_parm;
-        param = (if !cur.is_null() {
-            (*cur).data
-        } else {
-            0 as *mut libc::c_void
-        }) as *mut mailmime_disposition_parm;
-        display_mime_dsp_parm(param);
-        cur = if !cur.is_null() {
-            (*cur).next
-        } else {
-            0 as *mut clistcell
-        }
-    }
-}
-unsafe fn display_mime_field(mut field: *mut mailmime_field) {
-    match (*field).fld_type {
-        1 => {
-            print!("content-type: ");
-            display_mime_content((*field).fld_data.fld_content);
-            println!("");
-        }
-        6 => {
-            display_mime_disposition((*field).fld_data.fld_disposition);
-        }
-        _ => {}
-    };
-}
-unsafe fn display_mime_fields(mut fields: *mut mailmime_fields) {
-    let mut cur: *mut clistiter = 0 as *mut clistiter;
-    cur = (*(*fields).fld_list).first;
-    while !cur.is_null() {
-        let mut field: *mut mailmime_field = 0 as *mut mailmime_field;
-        field = (if !cur.is_null() {
-            (*cur).data
-        } else {
-            0 as *mut libc::c_void
-        }) as *mut mailmime_field;
-        display_mime_field(field);
-        cur = if !cur.is_null() {
-            (*cur).next
-        } else {
-            0 as *mut clistcell
-        }
-    }
-}
-unsafe fn display_date_time(mut d: *mut mailimf_date_time) {
-    print!(
-        "{:02}/{:02}/{:02} {:02}:{:02}:{:02} +{:04}",
-        (*d).dt_day,
-        (*d).dt_month,
-        (*d).dt_year,
-        (*d).dt_hour,
-        (*d).dt_min,
-        (*d).dt_sec,
-        (*d).dt_zone,
-    );
-}
-unsafe fn display_orig_date(mut orig_date: *mut mailimf_orig_date) {
-    display_date_time((*orig_date).dt_date_time);
-}
-unsafe fn display_mailbox(mut mb: *mut mailimf_mailbox) {
-    if !(*mb).mb_display_name.is_null() {
-        print!(
-            "{}",
-            CStr::from_ptr((*mb).mb_display_name).to_str().unwrap()
-        );
-    }
-    print!("<{}>", CStr::from_ptr((*mb).mb_addr_spec).to_str().unwrap());
-}
-unsafe fn display_mailbox_list(mut mb_list: *mut mailimf_mailbox_list) {
-    let mut cur: *mut clistiter = 0 as *mut clistiter;
-    cur = (*(*mb_list).mb_list).first;
-    while !cur.is_null() {
-        let mut mb: *mut mailimf_mailbox = 0 as *mut mailimf_mailbox;
-        mb = (if !cur.is_null() {
-            (*cur).data
-        } else {
-            0 as *mut libc::c_void
-        }) as *mut mailimf_mailbox;
-        display_mailbox(mb);
-        if !if !cur.is_null() {
-            (*cur).next
-        } else {
-            0 as *mut clistcell
-        }
-        .is_null()
-        {
-            print!(", ");
-        }
-        cur = if !cur.is_null() {
-            (*cur).next
-        } else {
-            0 as *mut clistcell
-        }
-    }
-}
-unsafe fn display_group(mut group: *mut mailimf_group) {
-    let mut cur: *mut clistiter = 0 as *mut clistiter;
-    print!(
-        "{}: ",
-        CStr::from_ptr((*group).grp_display_name).to_str().unwrap()
-    );
-    cur = (*(*(*group).grp_mb_list).mb_list).first;
-    while !cur.is_null() {
-        let mut mb: *mut mailimf_mailbox = 0 as *mut mailimf_mailbox;
-        mb = (if !cur.is_null() {
-            (*cur).data
-        } else {
-            0 as *mut libc::c_void
-        }) as *mut mailimf_mailbox;
-        display_mailbox(mb);
-        cur = if !cur.is_null() {
-            (*cur).next
-        } else {
-            0 as *mut clistcell
-        }
-    }
-    print!("; ");
-}
-unsafe fn display_address(mut a: *mut mailimf_address) {
-    match (*a).ad_type {
-        2 => {
-            display_group((*a).ad_data.ad_group);
-        }
-        1 => {
-            display_mailbox((*a).ad_data.ad_mailbox);
-        }
-        _ => {}
-    };
-}
-unsafe fn display_address_list(mut addr_list: *mut mailimf_address_list) {
-    let mut cur: *mut clistiter = 0 as *mut clistiter;
-    cur = (*(*addr_list).ad_list).first;
-    while !cur.is_null() {
-        let mut addr: *mut mailimf_address = 0 as *mut mailimf_address;
-        addr = (if !cur.is_null() {
-            (*cur).data
-        } else {
-            0 as *mut libc::c_void
-        }) as *mut mailimf_address;
-        display_address(addr);
-        if !if !cur.is_null() {
-            (*cur).next
-        } else {
-            0 as *mut clistcell
-        }
-        .is_null()
-        {
-            print!(", ");
-        }
-        cur = if !cur.is_null() {
-            (*cur).next
-        } else {
-            0 as *mut clistcell
-        }
-    }
-}
-unsafe fn display_from(mut from: *mut mailimf_from) {
-    display_mailbox_list((*from).frm_mb_list);
-}
-unsafe fn display_to(mut to: *mut mailimf_to) {
-    display_address_list((*to).to_addr_list);
-}
-unsafe fn display_cc(mut cc: *mut mailimf_cc) {
-    display_address_list((*cc).cc_addr_list);
-}
-unsafe fn display_subject(mut subject: *mut mailimf_subject) {
-    print!("{}", CStr::from_ptr((*subject).sbj_value).to_str().unwrap());
-}
-unsafe fn display_field(mut field: *mut mailimf_field) {
-    match (*field).fld_type {
-        9 => {
-            print!("Date: ");
-            display_orig_date((*field).fld_data.fld_orig_date);
-            println!("");
-        }
-        10 => {
-            print!("From: ");
-            display_from((*field).fld_data.fld_from);
-            println!("");
-        }
-        13 => {
-            print!("To: ");
-            display_to((*field).fld_data.fld_to);
-            println!("");
-        }
-        14 => {
-            print!("Cc: ");
-            display_cc((*field).fld_data.fld_cc);
-            println!("");
-        }
-        19 => {
-            print!("Subject: ");
-            display_subject((*field).fld_data.fld_subject);
-            println!("");
-        }
-        16 => {
-            println!(
-                "Message-ID: {}",
-                CStr::from_ptr((*(*field).fld_data.fld_message_id).mid_value)
-                    .to_str()
-                    .unwrap(),
-            );
-        }
-        _ => {}
-    };
-}
-unsafe fn display_fields(mut fields: *mut mailimf_fields) {
-    let mut cur: *mut clistiter = 0 as *mut clistiter;
-    cur = (*(*fields).fld_list).first;
-    while !cur.is_null() {
-        let mut f: *mut mailimf_field = 0 as *mut mailimf_field;
-        f = (if !cur.is_null() {
-            (*cur).data
-        } else {
-            0 as *mut libc::c_void
-        }) as *mut mailimf_field;
-        display_field(f);
-        cur = if !cur.is_null() {
-            (*cur).next
-        } else {
-            0 as *mut clistcell
-        }
-    }
-}

mmime/src/lib.rs

@@ -1,78 +0,0 @@
-#![deny(clippy::correctness)]
-// TODO: make all of these errors, such that clippy actually passes.
-#![warn(clippy::all, clippy::perf, clippy::not_unsafe_ptr_arg_deref)]
-// This is nice, but for now just annoying.
-#![allow(clippy::unreadable_literal)]
-#![feature(ptr_wrapping_offset_from)]
-#![allow(unused_attributes)]
-#![allow(unused_variables)]
-#![allow(mutable_transmutes)]
-#![allow(non_camel_case_types)]
-#![allow(non_snake_case)]
-#![allow(non_upper_case_globals)]
-#![allow(unused_assignments)]
-#![allow(unused_mut)]
-#![allow(unused_must_use)]
-#![feature(extern_types)]
-#![feature(const_raw_ptr_to_usize_cast)]
-
-pub mod charconv;
-pub mod chash;
-pub mod clist;
-pub mod display;
-pub mod mailimf;
-pub mod mailmime;
-pub mod mmapstring;
-pub mod other;
-
-pub use self::charconv::*;
-pub use self::chash::*;
-pub use self::clist::*;
-pub use self::display::*;
-pub use self::mailimf::*;
-pub use self::mailmime::*;
-pub use self::mmapstring::*;
-pub use self::other::*;
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn mailmime_parse_test() {
-        unsafe {
-            let data = "MIME-Version: 1.0\
-                        Content-Type: multipart/mixed; boundary=frontier\
-                        \
-                        This is a message with multiple parts in MIME format.\
-                        --frontier\
-                        Content-Type: text/plain\
-                        \
-                        This is the body of the message.\
-                        --frontier\
-                        Content-Type: application/octet-stream\
-                        Content-Transfer-Encoding: base64\
-                        \
-                        PGh0bWw+CiAgPGhlYWQ+CiAgPC9oZWFkPgogIDxib2R5PgogICAgPHA+VGhpcyBpcyB0aGUg\
-                        Ym9keSBvZiB0aGUgbWVzc2FnZS48L3A+CiAgPC9ib2R5Pgo8L2h0bWw+Cg==\
-                        --frontier--";
-            let c_data = std::ffi::CString::new(data).unwrap();
-
-            let mut current_index = 0;
-            let mut mime = std::ptr::null_mut();
-            let res = crate::mailmime::content::mailmime_parse(
-                c_data.as_ptr(),
-                data.len() as usize,
-                &mut current_index,
-                &mut mime,
-            );
-
-            assert_eq!(res, MAIL_NO_ERROR as libc::c_int);
-            assert!(!mime.is_null());
-
-            display_mime(mime);
-
-            mailmime::types::mailmime_free(mime);
-        }
-    }
-}

mmime/src/mailimf/types_helper.rs

@@ -1,89 +0,0 @@
-use crate::clist::*;
-use crate::mailimf::types::*;
-use crate::other::*;
-
-/*
-  this function creates a new mailimf_fields structure with no fields
-*/
-pub unsafe fn mailimf_fields_new_empty() -> *mut mailimf_fields {
-    let mut list: *mut clist = 0 as *mut clist;
-    let mut fields_list: *mut mailimf_fields = 0 as *mut mailimf_fields;
-    list = clist_new();
-    if list.is_null() {
-        return 0 as *mut mailimf_fields;
-    }
-    fields_list = mailimf_fields_new(list);
-    if fields_list.is_null() {
-        return 0 as *mut mailimf_fields;
-    }
-    return fields_list;
-}
-/*
- this function adds a field to the mailimf_fields structure
-
- @return MAILIMF_NO_ERROR will be returned on success,
- other code will be returned otherwise
-*/
-pub unsafe fn mailimf_fields_add(
-    mut fields: *mut mailimf_fields,
-    mut field: *mut mailimf_field,
-) -> libc::c_int {
-    let mut r: libc::c_int = 0;
-    r = clist_insert_after(
-        (*fields).fld_list,
-        (*(*fields).fld_list).last,
-        field as *mut libc::c_void,
-    );
-    if r < 0i32 {
-        return MAILIMF_ERROR_MEMORY as libc::c_int;
-    }
-    return MAILIMF_NO_ERROR as libc::c_int;
-}
-
-/*
-  mailimf_field_new_custom creates a new field of type optional
-
-  @param name should be allocated with malloc()
-  @param value should be allocated with malloc()
-*/
-pub unsafe fn mailimf_field_new_custom(
-    mut name: *mut libc::c_char,
-    mut value: *mut libc::c_char,
-) -> *mut mailimf_field {
-    let mut opt_field: *mut mailimf_optional_field = 0 as *mut mailimf_optional_field;
-    let mut field: *mut mailimf_field = 0 as *mut mailimf_field;
-    opt_field = mailimf_optional_field_new(name, value);
-    if !opt_field.is_null() {
-        field = mailimf_field_new(
-            MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int,
-            0 as *mut mailimf_return,
-            0 as *mut mailimf_orig_date,
-            0 as *mut mailimf_from,
-            0 as *mut mailimf_sender,
-            0 as *mut mailimf_to,
-            0 as *mut mailimf_cc,
-            0 as *mut mailimf_bcc,
-            0 as *mut mailimf_message_id,
-            0 as *mut mailimf_orig_date,
-            0 as *mut mailimf_from,
-            0 as *mut mailimf_sender,
-            0 as *mut mailimf_reply_to,
-            0 as *mut mailimf_to,
-            0 as *mut mailimf_cc,
-            0 as *mut mailimf_bcc,
-            0 as *mut mailimf_message_id,
-            0 as *mut mailimf_in_reply_to,
-            0 as *mut mailimf_references,
-            0 as *mut mailimf_subject,
-            0 as *mut mailimf_comments,
-            0 as *mut mailimf_keywords,
-            opt_field,
-        );
-        if field.is_null() {
-            mailimf_optional_field_free(opt_field);
-        } else {
-            return field;
-        }
-    }
-    return 0 as *mut mailimf_field;
-}

mmime/src/mailmime/decode.rs

@@ -1,860 +0,0 @@
-use libc;
-use libc::toupper;
-
-use crate::charconv::*;
-use crate::mailimf::*;
-use crate::mailmime::content::*;
-use crate::mailmime::types::*;
-use crate::mmapstring::*;
-use crate::other::*;
-
-pub const TYPE_WORD: libc::c_uint = 1;
-pub const TYPE_ENCODED_WORD: libc::c_uint = 2;
-pub const MAILMIME_ENCODING_Q: libc::c_uint = 1;
-pub const MAILMIME_ENCODING_B: libc::c_uint = 0;
-pub const TYPE_ERROR: libc::c_uint = 0;
-
-pub unsafe fn mailmime_encoded_phrase_parse(
-    mut default_fromcode: *const libc::c_char,
-    mut message: *const libc::c_char,
-    mut length: size_t,
-    mut indx: *mut size_t,
-    mut tocode: *const libc::c_char,
-    mut result: *mut *mut libc::c_char,
-) -> libc::c_int {
-    let mut current_block: u64;
-    let mut gphrase: *mut MMAPString = 0 as *mut MMAPString;
-    let mut word: *mut mailmime_encoded_word = 0 as *mut mailmime_encoded_word;
-    let mut first: libc::c_int = 0;
-    let mut cur_token: size_t = 0;
-    let mut r: libc::c_int = 0;
-    let mut res: libc::c_int = 0;
-    let mut str: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut wordutf8: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut type_0: libc::c_int = 0;
-    let mut missing_closing_quote: libc::c_int = 0;
-    cur_token = *indx;
-    gphrase = mmap_string_new(b"\x00" as *const u8 as *const libc::c_char);
-    if gphrase.is_null() {
-        res = MAILIMF_ERROR_MEMORY as libc::c_int
-    } else {
-        first = 1i32;
-        type_0 = TYPE_ERROR as libc::c_int;
-        loop {
-            let mut has_fwd: libc::c_int = 0;
-            word = 0 as *mut mailmime_encoded_word;
-            r = mailmime_encoded_word_parse(
-                message,
-                length,
-                &mut cur_token,
-                &mut word,
-                &mut has_fwd,
-                &mut missing_closing_quote,
-            );
-            if r == MAILIMF_NO_ERROR as libc::c_int {
-                if 0 == first && 0 != has_fwd {
-                    if type_0 != TYPE_ENCODED_WORD as libc::c_int {
-                        if mmap_string_append_c(gphrase, ' ' as i32 as libc::c_char).is_null() {
-                            mailmime_encoded_word_free(word);
-                            res = MAILIMF_ERROR_MEMORY as libc::c_int;
-                            current_block = 13246848547199022064;
-                            break;
-                        }
-                    }
-                }
-                type_0 = TYPE_ENCODED_WORD as libc::c_int;
-                wordutf8 = 0 as *mut libc::c_char;
-                r = charconv(
-                    tocode,
-                    (*word).wd_charset,
-                    (*word).wd_text,
-                    strlen((*word).wd_text),
-                    &mut wordutf8,
-                );
-                match r {
-                    2 => {
-                        mailmime_encoded_word_free(word);
-                        res = MAILIMF_ERROR_MEMORY as libc::c_int;
-                        current_block = 13246848547199022064;
-                        break;
-                    }
-                    1 => {
-                        r = charconv(
-                            tocode,
-                            b"iso-8859-1\x00" as *const u8 as *const libc::c_char,
-                            (*word).wd_text,
-                            strlen((*word).wd_text),
-                            &mut wordutf8,
-                        )
-                    }
-                    3 => {
-                        mailmime_encoded_word_free(word);
-                        res = MAILIMF_ERROR_PARSE as libc::c_int;
-                        current_block = 13246848547199022064;
-                        break;
-                    }
-                    _ => {}
-                }
-                match r {
-                    2 => {
-                        mailmime_encoded_word_free(word);
-                        res = MAILIMF_ERROR_MEMORY as libc::c_int;
-                        current_block = 13246848547199022064;
-                        break;
-                    }
-                    3 => {
-                        mailmime_encoded_word_free(word);
-                        res = MAILIMF_ERROR_PARSE as libc::c_int;
-                        current_block = 13246848547199022064;
-                        break;
-                    }
-                    _ => {
-                        if !wordutf8.is_null() {
-                            if mmap_string_append(gphrase, wordutf8).is_null() {
-                                mailmime_encoded_word_free(word);
-                                free(wordutf8 as *mut libc::c_void);
-                                res = MAILIMF_ERROR_MEMORY as libc::c_int;
-                                current_block = 13246848547199022064;
-                                break;
-                            } else {
-                                free(wordutf8 as *mut libc::c_void);
-                            }
-                        }
-                        mailmime_encoded_word_free(word);
-                        first = 0i32
-                    }
-                }
-            } else if !(r == MAILIMF_ERROR_PARSE as libc::c_int) {
-                /* do nothing */
-                res = r;
-                current_block = 13246848547199022064;
-                break;
-            }
-            if !(r == MAILIMF_ERROR_PARSE as libc::c_int) {
-                continue;
-            }
-            let mut raw_word: *mut libc::c_char = 0 as *mut libc::c_char;
-            raw_word = 0 as *mut libc::c_char;
-            r = mailmime_non_encoded_word_parse(
-                message,
-                length,
-                &mut cur_token,
-                &mut raw_word,
-                &mut has_fwd,
-            );
-            if r == MAILIMF_NO_ERROR as libc::c_int {
-                if 0 == first && 0 != has_fwd {
-                    if mmap_string_append_c(gphrase, ' ' as i32 as libc::c_char).is_null() {
-                        free(raw_word as *mut libc::c_void);
-                        res = MAILIMF_ERROR_MEMORY as libc::c_int;
-                        current_block = 13246848547199022064;
-                        break;
-                    }
-                }
-                type_0 = TYPE_WORD as libc::c_int;
-                wordutf8 = 0 as *mut libc::c_char;
-                r = charconv(
-                    tocode,
-                    default_fromcode,
-                    raw_word,
-                    strlen(raw_word),
-                    &mut wordutf8,
-                );
-                match r {
-                    2 => {
-                        free(raw_word as *mut libc::c_void);
-                        res = MAILIMF_ERROR_MEMORY as libc::c_int;
-                        current_block = 13246848547199022064;
-                        break;
-                    }
-                    1 | 3 => {
-                        free(raw_word as *mut libc::c_void);
-                        res = MAILIMF_ERROR_PARSE as libc::c_int;
-                        current_block = 13246848547199022064;
-                        break;
-                    }
-                    _ => {
-                        if mmap_string_append(gphrase, wordutf8).is_null() {
-                            free(wordutf8 as *mut libc::c_void);
-                            free(raw_word as *mut libc::c_void);
-                            res = MAILIMF_ERROR_MEMORY as libc::c_int;
-                            current_block = 13246848547199022064;
-                            break;
-                        } else {
-                            free(wordutf8 as *mut libc::c_void);
-                            free(raw_word as *mut libc::c_void);
-                            first = 0i32
-                        }
-                    }
-                }
-            } else if r == MAILIMF_ERROR_PARSE as libc::c_int {
-                r = mailimf_fws_parse(message, length, &mut cur_token);
-                if r != MAILIMF_NO_ERROR as libc::c_int {
-                    current_block = 5005389895767293342;
-                    break;
-                }
-                if mmap_string_append_c(gphrase, ' ' as i32 as libc::c_char).is_null() {
-                    res = MAILIMF_ERROR_MEMORY as libc::c_int;
-                    current_block = 13246848547199022064;
-                    break;
-                } else {
-                    first = 0i32;
-                    current_block = 5005389895767293342;
-                    break;
-                }
-            } else {
-                res = r;
-                current_block = 13246848547199022064;
-                break;
-            }
-        }
-        match current_block {
-            5005389895767293342 => {
-                if 0 != first {
-                    if cur_token != length {
-                        res = MAILIMF_ERROR_PARSE as libc::c_int;
-                        current_block = 13246848547199022064;
-                    } else {
-                        current_block = 7072655752890836508;
-                    }
-                } else {
-                    current_block = 7072655752890836508;
-                }
-                match current_block {
-                    13246848547199022064 => {}
-                    _ => {
-                        str = strdup((*gphrase).str_0);
-                        if str.is_null() {
-                            res = MAILIMF_ERROR_MEMORY as libc::c_int
-                        } else {
-                            mmap_string_free(gphrase);
-                            *result = str;
-                            *indx = cur_token;
-                            return MAILIMF_NO_ERROR as libc::c_int;
-                        }
-                    }
-                }
-            }
-            _ => {}
-        }
-        mmap_string_free(gphrase);
-    }
-    return res;
-}
-unsafe fn mailmime_non_encoded_word_parse(
-    mut message: *const libc::c_char,
-    mut length: size_t,
-    mut indx: *mut size_t,
-    mut result: *mut *mut libc::c_char,
-    mut p_has_fwd: *mut libc::c_int,
-) -> libc::c_int {
-    let mut end: libc::c_int = 0;
-    let mut cur_token: size_t = 0;
-    let mut res: libc::c_int = 0;
-    let mut text: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut r: libc::c_int = 0;
-    let mut begin: size_t = 0;
-    let mut state: libc::c_int = 0;
-    let mut has_fwd: libc::c_int = 0;
-    cur_token = *indx;
-    has_fwd = 0i32;
-    r = mailimf_fws_parse(message, length, &mut cur_token);
-    if r == MAILIMF_NO_ERROR as libc::c_int {
-        has_fwd = 1i32
-    }
-    if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int {
-        res = r
-    } else {
-        begin = cur_token;
-        state = 0i32;
-        end = 0i32;
-        while !(cur_token >= length) {
-            let mut current_block_17: u64;
-            match *message.offset(cur_token as isize) as libc::c_int {
-                32 | 9 | 13 | 10 => {
-                    state = 0i32;
-                    end = 1i32;
-                    current_block_17 = 16924917904204750491;
-                }
-                61 => {
-                    state = 1i32;
-                    current_block_17 = 16924917904204750491;
-                }
-                63 => {
-                    if state == 1i32 {
-                        cur_token = cur_token.wrapping_sub(1);
-                        end = 1i32
-                    }
-                    current_block_17 = 10192508258555769664;
-                }
-                _ => {
-                    current_block_17 = 10192508258555769664;
-                }
-            }
-            match current_block_17 {
-                10192508258555769664 => state = 0i32,
-                _ => {}
-            }
-            if 0 != end {
-                break;
-            }
-            cur_token = cur_token.wrapping_add(1)
-        }
-        if cur_token.wrapping_sub(begin) == 0i32 as libc::size_t {
-            res = MAILIMF_ERROR_PARSE as libc::c_int
-        } else {
-            text = malloc(
-                cur_token
-                    .wrapping_sub(begin)
-                    .wrapping_add(1i32 as libc::size_t),
-            ) as *mut libc::c_char;
-            if text.is_null() {
-                res = MAILIMF_ERROR_MEMORY as libc::c_int
-            } else {
-                memcpy(
-                    text as *mut libc::c_void,
-                    message.offset(begin as isize) as *const libc::c_void,
-                    cur_token.wrapping_sub(begin),
-                );
-                *text.offset(cur_token.wrapping_sub(begin) as isize) =
-                    '\u{0}' as i32 as libc::c_char;
-                *indx = cur_token;
-                *result = text;
-                *p_has_fwd = has_fwd;
-                return MAILIMF_NO_ERROR as libc::c_int;
-            }
-        }
-    }
-    return res;
-}
-
-pub unsafe fn mailmime_encoded_word_parse(
-    mut message: *const libc::c_char,
-    mut length: size_t,
-    mut indx: *mut size_t,
-    mut result: *mut *mut mailmime_encoded_word,
-    mut p_has_fwd: *mut libc::c_int,
-    mut p_missing_closing_quote: *mut libc::c_int,
-) -> libc::c_int {
-    let mut current_block: u64;
-    /*
-    Parse the following, when a unicode character encoding is split.
-    =?UTF-8?B?4Lij4Liw4LmA4Lia4Li04LiU4LiE4Lin4Liy4Lih4Lih4Lix4LiZ4Liq4LmM?=
-    =?UTF-8?B?4LmA4LiV4LmH4Lih4Lie4Li04LiB4Lix4LiUIFRSQU5TRk9STUVSUyA0IOC4?=
-    =?UTF-8?B?oeC4seC4meC4quC5jOC4hOC4o+C4muC4l+C4uOC4geC4o+C4sOC4muC4miDg?=
-    =?UTF-8?B?uJfguLXguYjguYDguJTguLXguKLguKfguYPguJnguYDguKHguLfguK3guIfg?=
-    =?UTF-8?B?uYTguJfguKI=?=
-    Expected result:
-    ระเบิดความมันส์เต็มพิกัด TRANSFORMERS 4 มันส์ครบทุกระบบ ที่เดียวในเมืองไทย
-    libetpan result:
-    ระเบิดความมันส์เต็มพิกัด TRANSFORMERS 4 ?ันส์ครบทุกระบบ ??ี่เดียวในเมือง??ทย
-
-    See https://github.com/dinhviethoa/libetpan/pull/211
-    */
-    let mut cur_token: size_t = 0;
-    let mut charset: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut encoding: libc::c_int = 0;
-    let mut body: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut old_body_len: size_t = 0;
-    let mut text: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut end_encoding: size_t = 0;
-    let mut lookfwd_cur_token: size_t = 0;
-    let mut lookfwd_charset: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut lookfwd_encoding: libc::c_int = 0;
-    let mut copy_len: size_t = 0;
-    let mut decoded_token: size_t = 0;
-    let mut decoded: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut decoded_len: size_t = 0;
-    let mut ew: *mut mailmime_encoded_word = 0 as *mut mailmime_encoded_word;
-    let mut r: libc::c_int = 0;
-    let mut res: libc::c_int = 0;
-    let mut opening_quote: libc::c_int = 0;
-    let mut end: libc::c_int = 0;
-    let mut has_fwd: libc::c_int = 0;
-    let mut missing_closing_quote: libc::c_int = 0;
-    cur_token = *indx;
-    text = 0 as *mut libc::c_char;
-    lookfwd_charset = 0 as *mut libc::c_char;
-    missing_closing_quote = 0i32;
-    has_fwd = 0i32;
-    r = mailimf_fws_parse(message, length, &mut cur_token);
-    if r == MAILIMF_NO_ERROR as libc::c_int {
-        has_fwd = 1i32
-    }
-    if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int {
-        res = r
-    } else {
-        opening_quote = 0i32;
-        r = mailimf_char_parse(message, length, &mut cur_token, '\"' as i32 as libc::c_char);
-        if r == MAILIMF_NO_ERROR as libc::c_int {
-            opening_quote = 1i32;
-            current_block = 17788412896529399552;
-        } else if r == MAILIMF_ERROR_PARSE as libc::c_int {
-            current_block = 17788412896529399552;
-        } else {
-            /* do nothing */
-            res = r;
-            current_block = 7995813543095296079;
-        }
-        match current_block {
-            7995813543095296079 => {}
-            _ => {
-                r = mailimf_token_case_insensitive_len_parse(
-                    message,
-                    length,
-                    &mut cur_token,
-                    b"=?\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
-                    strlen(b"=?\x00" as *const u8 as *const libc::c_char),
-                );
-                if r != MAILIMF_NO_ERROR as libc::c_int {
-                    res = r
-                } else {
-                    r = mailmime_charset_parse(message, length, &mut cur_token, &mut charset);
-                    if r != MAILIMF_NO_ERROR as libc::c_int {
-                        res = r
-                    } else {
-                        r = mailimf_char_parse(
-                            message,
-                            length,
-                            &mut cur_token,
-                            '?' as i32 as libc::c_char,
-                        );
-                        if r != MAILIMF_NO_ERROR as libc::c_int {
-                            res = r
-                        } else {
-                            r = mailmime_encoding_parse(
-                                message,
-                                length,
-                                &mut cur_token,
-                                &mut encoding,
-                            );
-                            if r != MAILIMF_NO_ERROR as libc::c_int {
-                                res = r
-                            } else {
-                                r = mailimf_char_parse(
-                                    message,
-                                    length,
-                                    &mut cur_token,
-                                    '?' as i32 as libc::c_char,
-                                );
-                                if r != MAILIMF_NO_ERROR as libc::c_int {
-                                    res = r
-                                } else {
-                                    lookfwd_cur_token = cur_token;
-                                    body = 0 as *mut libc::c_char;
-                                    old_body_len = 0i32 as size_t;
-                                    loop {
-                                        let mut has_base64_padding: libc::c_int = 0;
-                                        end = 0i32;
-                                        has_base64_padding = 0i32;
-                                        end_encoding = cur_token;
-                                        while !(end_encoding >= length) {
-                                            if end_encoding.wrapping_add(1i32 as libc::size_t)
-                                                < length
-                                            {
-                                                if *message.offset(end_encoding as isize)
-                                                    as libc::c_int
-                                                    == '?' as i32
-                                                    && *message.offset(
-                                                        end_encoding
-                                                            .wrapping_add(1i32 as libc::size_t)
-                                                            as isize,
-                                                    )
-                                                        as libc::c_int
-                                                        == '=' as i32
-                                                {
-                                                    end = 1i32
-                                                }
-                                            }
-                                            if 0 != end {
-                                                break;
-                                            }
-                                            end_encoding = end_encoding.wrapping_add(1)
-                                        }
-                                        copy_len = end_encoding.wrapping_sub(lookfwd_cur_token);
-                                        if copy_len > 0i32 as libc::size_t {
-                                            if encoding == MAILMIME_ENCODING_B as libc::c_int {
-                                                if end_encoding >= 1i32 as libc::size_t {
-                                                    if *message.offset(
-                                                        end_encoding
-                                                            .wrapping_sub(1i32 as libc::size_t)
-                                                            as isize,
-                                                    )
-                                                        as libc::c_int
-                                                        == '=' as i32
-                                                    {
-                                                        has_base64_padding = 1i32
-                                                    }
-                                                }
-                                            }
-                                            body = realloc(
-                                                body as *mut libc::c_void,
-                                                old_body_len
-                                                    .wrapping_add(copy_len)
-                                                    .wrapping_add(1i32 as libc::size_t),
-                                            )
-                                                as *mut libc::c_char;
-                                            if body.is_null() {
-                                                res = MAILIMF_ERROR_MEMORY as libc::c_int;
-                                                current_block = 13900684162107791171;
-                                                break;
-                                            } else {
-                                                memcpy(
-                                                    body.offset(old_body_len as isize)
-                                                        as *mut libc::c_void,
-                                                    &*message.offset(cur_token as isize)
-                                                        as *const libc::c_char
-                                                        as *const libc::c_void,
-                                                    copy_len,
-                                                );
-                                                *body
-                                                    .offset(old_body_len.wrapping_add(copy_len)
-                                                        as isize) = '\u{0}' as i32 as libc::c_char;
-                                                old_body_len = (old_body_len as libc::size_t)
-                                                    .wrapping_add(copy_len)
-                                                    as size_t
-                                                    as size_t
-                                            }
-                                        }
-                                        cur_token = end_encoding;
-                                        r = mailimf_token_case_insensitive_len_parse(
-                                            message,
-                                            length,
-                                            &mut cur_token,
-                                            b"?=\x00" as *const u8 as *const libc::c_char
-                                                as *mut libc::c_char,
-                                            strlen(b"?=\x00" as *const u8 as *const libc::c_char),
-                                        );
-                                        if r != MAILIMF_NO_ERROR as libc::c_int {
-                                            current_block = 2652804691515851435;
-                                            break;
-                                        }
-                                        if 0 != has_base64_padding {
-                                            current_block = 2652804691515851435;
-                                            break;
-                                        }
-                                        lookfwd_cur_token = cur_token;
-                                        r = mailimf_fws_parse(
-                                            message,
-                                            length,
-                                            &mut lookfwd_cur_token,
-                                        );
-                                        if r != MAILIMF_NO_ERROR as libc::c_int
-                                            && r != MAILIMF_ERROR_PARSE as libc::c_int
-                                        {
-                                            current_block = 2652804691515851435;
-                                            break;
-                                        }
-                                        r = mailimf_token_case_insensitive_len_parse(
-                                            message,
-                                            length,
-                                            &mut lookfwd_cur_token,
-                                            b"=?\x00" as *const u8 as *const libc::c_char
-                                                as *mut libc::c_char,
-                                            strlen(b"=?\x00" as *const u8 as *const libc::c_char),
-                                        );
-                                        if r != MAILIMF_NO_ERROR as libc::c_int {
-                                            current_block = 2652804691515851435;
-                                            break;
-                                        }
-                                        r = mailmime_charset_parse(
-                                            message,
-                                            length,
-                                            &mut lookfwd_cur_token,
-                                            &mut lookfwd_charset,
-                                        );
-                                        if r != MAILIMF_NO_ERROR as libc::c_int {
-                                            current_block = 2652804691515851435;
-                                            break;
-                                        }
-                                        r = mailimf_char_parse(
-                                            message,
-                                            length,
-                                            &mut lookfwd_cur_token,
-                                            '?' as i32 as libc::c_char,
-                                        );
-                                        if r != MAILIMF_NO_ERROR as libc::c_int {
-                                            current_block = 2652804691515851435;
-                                            break;
-                                        }
-                                        r = mailmime_encoding_parse(
-                                            message,
-                                            length,
-                                            &mut lookfwd_cur_token,
-                                            &mut lookfwd_encoding,
-                                        );
-                                        if r != MAILIMF_NO_ERROR as libc::c_int {
-                                            current_block = 2652804691515851435;
-                                            break;
-                                        }
-                                        r = mailimf_char_parse(
-                                            message,
-                                            length,
-                                            &mut lookfwd_cur_token,
-                                            '?' as i32 as libc::c_char,
-                                        );
-                                        if r != MAILIMF_NO_ERROR as libc::c_int {
-                                            current_block = 2652804691515851435;
-                                            break;
-                                        }
-                                        if strcasecmp(charset, lookfwd_charset) == 0i32
-                                            && encoding == lookfwd_encoding
-                                        {
-                                            cur_token = lookfwd_cur_token;
-                                            mailmime_charset_free(lookfwd_charset);
-                                            lookfwd_charset = 0 as *mut libc::c_char
-                                        } else {
-                                            /* the next charset is not matched with the current one,
-                                            therefore exit the loop to decode the body appended so far */
-                                            current_block = 2652804691515851435;
-                                            break;
-                                        }
-                                    }
-                                    match current_block {
-                                        2652804691515851435 => {
-                                            if !lookfwd_charset.is_null() {
-                                                mailmime_charset_free(lookfwd_charset);
-                                                lookfwd_charset = 0 as *mut libc::c_char
-                                            }
-                                            if body.is_null() {
-                                                body = strdup(
-                                                    b"\x00" as *const u8 as *const libc::c_char,
-                                                );
-                                                if body.is_null() {
-                                                    res = MAILIMF_ERROR_MEMORY as libc::c_int;
-                                                    current_block = 13900684162107791171;
-                                                } else {
-                                                    current_block = 16778110326724371720;
-                                                }
-                                            } else {
-                                                current_block = 16778110326724371720;
-                                            }
-                                            match current_block {
-                                                13900684162107791171 => {}
-                                                _ => {
-                                                    decoded_token = 0i32 as size_t;
-                                                    decoded_len = 0i32 as size_t;
-                                                    decoded = 0 as *mut libc::c_char;
-                                                    match encoding {
-                                                        0 => {
-                                                            r = mailmime_base64_body_parse(
-                                                                body,
-                                                                strlen(body),
-                                                                &mut decoded_token,
-                                                                &mut decoded,
-                                                                &mut decoded_len,
-                                                            );
-                                                            if r != MAILIMF_NO_ERROR as libc::c_int
-                                                            {
-                                                                res = r;
-                                                                current_block =
-                                                                    13900684162107791171;
-                                                            } else {
-                                                                current_block = 7337917895049117968;
-                                                            }
-                                                        }
-                                                        1 => {
-                                                            r =
-                                                                mailmime_quoted_printable_body_parse(body,
-                                                                                                     strlen(body),
-                                                                                                     &mut decoded_token,
-                                                                                                     &mut decoded,
-                                                                                                     &mut decoded_len,
-                                                                                                     1i32);
-                                                            if r != MAILIMF_NO_ERROR as libc::c_int
-                                                            {
-                                                                res = r;
-                                                                current_block =
-                                                                    13900684162107791171;
-                                                            } else {
-                                                                current_block = 7337917895049117968;
-                                                            }
-                                                        }
-                                                        _ => {
-                                                            current_block = 7337917895049117968;
-                                                        }
-                                                    }
-                                                    match current_block {
-                                                        13900684162107791171 => {}
-                                                        _ => {
-                                                            text =
-                                                                malloc(decoded_len.wrapping_add(
-                                                                    1i32 as libc::size_t,
-                                                                ))
-                                                                    as *mut libc::c_char;
-                                                            if text.is_null() {
-                                                                res = MAILIMF_ERROR_MEMORY
-                                                                    as libc::c_int
-                                                            } else {
-                                                                if decoded_len
-                                                                    > 0i32 as libc::size_t
-                                                                {
-                                                                    memcpy(
-                                                                        text as *mut libc::c_void,
-                                                                        decoded
-                                                                            as *const libc::c_void,
-                                                                        decoded_len,
-                                                                    );
-                                                                }
-                                                                *text
-                                                                    .offset(decoded_len as isize) =
-                                                                    '\u{0}' as i32 as libc::c_char;
-                                                                if 0 != opening_quote {
-                                                                    r = mailimf_char_parse(
-                                                                        message,
-                                                                        length,
-                                                                        &mut cur_token,
-                                                                        '\"' as i32 as libc::c_char,
-                                                                    );
-                                                                    if r == MAILIMF_ERROR_PARSE
-                                                                        as libc::c_int
-                                                                    {
-                                                                        missing_closing_quote = 1i32
-                                                                    }
-                                                                }
-                                                                if strcasecmp(
-                                                                    charset,
-                                                                    b"utf8\x00" as *const u8
-                                                                        as *const libc::c_char,
-                                                                ) == 0i32
-                                                                {
-                                                                    free(
-                                                                        charset
-                                                                            as *mut libc::c_void,
-                                                                    );
-                                                                    charset = strdup(
-                                                                        b"utf-8\x00" as *const u8
-                                                                            as *const libc::c_char,
-                                                                    )
-                                                                }
-                                                                ew = mailmime_encoded_word_new(
-                                                                    charset, text,
-                                                                );
-                                                                if ew.is_null() {
-                                                                    res = MAILIMF_ERROR_MEMORY
-                                                                        as libc::c_int
-                                                                } else {
-                                                                    *result = ew;
-                                                                    *indx = cur_token;
-                                                                    *p_has_fwd = has_fwd;
-                                                                    *p_missing_closing_quote =
-                                                                        missing_closing_quote;
-                                                                    mailmime_decoded_part_free(
-                                                                        decoded,
-                                                                    );
-                                                                    free(body as *mut libc::c_void);
-                                                                    return MAILIMF_NO_ERROR
-                                                                        as libc::c_int;
-                                                                }
-                                                            }
-                                                            mailmime_decoded_part_free(decoded);
-                                                        }
-                                                    }
-                                                }
-                                            }
-                                        }
-                                        _ => {}
-                                    }
-                                    free(body as *mut libc::c_void);
-                                    mailmime_encoded_text_free(text);
-                                }
-                            }
-                        }
-                        mailmime_charset_free(charset);
-                    }
-                }
-            }
-        }
-    }
-    return res;
-}
-unsafe fn mailmime_encoding_parse(
-    mut message: *const libc::c_char,
-    mut length: size_t,
-    mut indx: *mut size_t,
-    mut result: *mut libc::c_int,
-) -> libc::c_int {
-    let mut cur_token: size_t = 0;
-    let mut encoding: libc::c_int = 0;
-    cur_token = *indx;
-    if cur_token >= length {
-        return MAILIMF_ERROR_PARSE as libc::c_int;
-    }
-    match toupper(*message.offset(cur_token as isize) as libc::c_uchar as libc::c_int)
-        as libc::c_char as libc::c_int
-    {
-        81 => encoding = MAILMIME_ENCODING_Q as libc::c_int,
-        66 => encoding = MAILMIME_ENCODING_B as libc::c_int,
-        _ => return MAILIMF_ERROR_INVAL as libc::c_int,
-    }
-    cur_token = cur_token.wrapping_add(1);
-    *result = encoding;
-    *indx = cur_token;
-    return MAILIMF_NO_ERROR as libc::c_int;
-}
-
-/*
- * libEtPan! -- a mail stuff library
- *
- * Copyright (C) 2001, 2005 - DINH Viet Hoa
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the libEtPan! project nor the names of its
- *    contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-/*
- * $Id: mailmime_decode.c,v 1.37 2010/11/16 20:52:28 hoa Exp $
- */
-/*
-  RFC 2047 : MIME (Multipurpose Internet Mail Extensions) Part Three:
-             Message Header Extensions for Non-ASCII Text
-*/
-unsafe fn mailmime_charset_parse(
-    mut message: *const libc::c_char,
-    mut length: size_t,
-    mut indx: *mut size_t,
-    mut charset: *mut *mut libc::c_char,
-) -> libc::c_int {
-    return mailmime_etoken_parse(message, length, indx, charset);
-}
-unsafe fn mailmime_etoken_parse(
-    mut message: *const libc::c_char,
-    mut length: size_t,
-    mut indx: *mut size_t,
-    mut result: *mut *mut libc::c_char,
-) -> libc::c_int {
-    return mailimf_custom_string_parse(message, length, indx, result, Some(is_etoken_char));
-}
-
-unsafe fn is_etoken_char(mut ch: libc::c_char) -> libc::c_int {
-    let mut uch: libc::c_uchar = ch as libc::c_uchar;
-    if (uch as libc::c_int) < 31i32 {
-        return 0i32;
-    }
-    match uch as libc::c_int {
-        32 | 40 | 41 | 60 | 62 | 64 | 44 | 59 | 58 | 34 | 47 | 91 | 93 | 63 | 61 => return 0i32,
-        _ => {}
-    }
-    return 1i32;
-}

mmime/src/mailmime/disposition.rs

@@ -1,583 +0,0 @@
-use libc::{self, toupper};
-
-use crate::clist::*;
-use crate::mailimf::*;
-use crate::mailmime::types::*;
-use crate::mailmime::*;
-use crate::other::*;
-
-pub const MAILMIME_DISPOSITION_TYPE_EXTENSION: libc::c_uint = 3;
-pub const MAILMIME_DISPOSITION_TYPE_ATTACHMENT: libc::c_uint = 2;
-pub const MAILMIME_DISPOSITION_TYPE_INLINE: libc::c_uint = 1;
-pub const MAILMIME_DISPOSITION_TYPE_ERROR: libc::c_uint = 0;
-
-pub unsafe fn mailmime_disposition_parse(
-    mut message: *const libc::c_char,
-    mut length: size_t,
-    mut indx: *mut size_t,
-    mut result: *mut *mut mailmime_disposition,
-) -> libc::c_int {
-    let mut current_block: u64;
-    let mut final_token: size_t = 0;
-    let mut cur_token: size_t = 0;
-    let mut dsp_type: *mut mailmime_disposition_type = 0 as *mut mailmime_disposition_type;
-    let mut list: *mut clist = 0 as *mut clist;
-    let mut dsp: *mut mailmime_disposition = 0 as *mut mailmime_disposition;
-    let mut r: libc::c_int = 0;
-    let mut res: libc::c_int = 0;
-    cur_token = *indx;
-    r = mailmime_disposition_type_parse(message, length, &mut cur_token, &mut dsp_type);
-    if r != MAILIMF_NO_ERROR as libc::c_int {
-        res = r
-    } else {
-        list = clist_new();
-        if list.is_null() {
-            res = MAILIMF_ERROR_MEMORY as libc::c_int
-        } else {
-            loop {
-                let mut param: *mut mailmime_disposition_parm = 0 as *mut mailmime_disposition_parm;
-                final_token = cur_token;
-                r = mailimf_unstrict_char_parse(
-                    message,
-                    length,
-                    &mut cur_token,
-                    ';' as i32 as libc::c_char,
-                );
-                if r == MAILIMF_NO_ERROR as libc::c_int {
-                    param = 0 as *mut mailmime_disposition_parm;
-                    r = mailmime_disposition_parm_parse(
-                        message,
-                        length,
-                        &mut cur_token,
-                        &mut param,
-                    );
-                    if r == MAILIMF_NO_ERROR as libc::c_int {
-                        r = clist_insert_after(list, (*list).last, param as *mut libc::c_void);
-                        if !(r < 0i32) {
-                            continue;
-                        }
-                        res = MAILIMF_ERROR_MEMORY as libc::c_int;
-                        current_block = 18290070879695007868;
-                        break;
-                    } else if r == MAILIMF_ERROR_PARSE as libc::c_int {
-                        cur_token = final_token;
-                        current_block = 652864300344834934;
-                        break;
-                    } else {
-                        res = r;
-                        current_block = 18290070879695007868;
-                        break;
-                    }
-                } else {
-                    /* do nothing */
-                    if r == MAILIMF_ERROR_PARSE as libc::c_int {
-                        current_block = 652864300344834934;
-                        break;
-                    }
-                    res = r;
-                    current_block = 18290070879695007868;
-                    break;
-                }
-            }
-            match current_block {
-                652864300344834934 => {
-                    dsp = mailmime_disposition_new(dsp_type, list);
-                    if dsp.is_null() {
-                        res = MAILIMF_ERROR_MEMORY as libc::c_int
-                    } else {
-                        *result = dsp;
-                        *indx = cur_token;
-                        return MAILIMF_NO_ERROR as libc::c_int;
-                    }
-                }
-                _ => {}
-            }
-            clist_foreach(
-                list,
-                ::std::mem::transmute::<
-                    Option<unsafe fn(_: *mut mailmime_disposition_parm) -> ()>,
-                    clist_func,
-                >(Some(mailmime_disposition_parm_free)),
-                0 as *mut libc::c_void,
-            );
-            clist_free(list);
-        }
-        mailmime_disposition_type_free(dsp_type);
-    }
-    return res;
-}
-/*
- * libEtPan! -- a mail stuff library
- *
- * Copyright (C) 2001, 2005 - DINH Viet Hoa
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the libEtPan! project nor the names of its
- *    contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-/*
- * $Id: mailmime_disposition.c,v 1.17 2011/05/03 16:30:22 hoa Exp $
- */
-unsafe fn mailmime_disposition_parm_parse(
-    mut message: *const libc::c_char,
-    mut length: size_t,
-    mut indx: *mut size_t,
-    mut result: *mut *mut mailmime_disposition_parm,
-) -> libc::c_int {
-    let mut current_block: u64;
-    let mut filename: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut creation_date: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut modification_date: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut read_date: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut size: size_t = 0;
-    let mut parameter: *mut mailmime_parameter = 0 as *mut mailmime_parameter;
-    let mut cur_token: size_t = 0;
-    let mut dsp_parm: *mut mailmime_disposition_parm = 0 as *mut mailmime_disposition_parm;
-    let mut type_0: libc::c_int = 0;
-    let mut guessed_type: libc::c_int = 0;
-    let mut r: libc::c_int = 0;
-    let mut res: libc::c_int = 0;
-    cur_token = *indx;
-    filename = 0 as *mut libc::c_char;
-    creation_date = 0 as *mut libc::c_char;
-    modification_date = 0 as *mut libc::c_char;
-    read_date = 0 as *mut libc::c_char;
-    size = 0i32 as size_t;
-    parameter = 0 as *mut mailmime_parameter;
-    r = mailimf_cfws_parse(message, length, &mut cur_token);
-    if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int {
-        res = r
-    } else {
-        guessed_type = mailmime_disposition_guess_type(message, length, cur_token);
-        type_0 = MAILMIME_DISPOSITION_PARM_PARAMETER as libc::c_int;
-        match guessed_type {
-            0 => {
-                r = mailmime_filename_parm_parse(message, length, &mut cur_token, &mut filename);
-                if r == MAILIMF_NO_ERROR as libc::c_int {
-                    type_0 = guessed_type;
-                    current_block = 13826291924415791078;
-                } else if r == MAILIMF_ERROR_PARSE as libc::c_int {
-                    current_block = 13826291924415791078;
-                } else {
-                    /* do nothing */
-                    res = r;
-                    current_block = 9120900589700563584;
-                }
-            }
-            1 => {
-                r = mailmime_creation_date_parm_parse(
-                    message,
-                    length,
-                    &mut cur_token,
-                    &mut creation_date,
-                );
-                if r == MAILIMF_NO_ERROR as libc::c_int {
-                    type_0 = guessed_type;
-                    current_block = 13826291924415791078;
-                } else if r == MAILIMF_ERROR_PARSE as libc::c_int {
-                    current_block = 13826291924415791078;
-                } else {
-                    /* do nothing */
-                    res = r;
-                    current_block = 9120900589700563584;
-                }
-            }
-            2 => {
-                r = mailmime_modification_date_parm_parse(
-                    message,
-                    length,
-                    &mut cur_token,
-                    &mut modification_date,
-                );
-                if r == MAILIMF_NO_ERROR as libc::c_int {
-                    type_0 = guessed_type;
-                    current_block = 13826291924415791078;
-                } else if r == MAILIMF_ERROR_PARSE as libc::c_int {
-                    current_block = 13826291924415791078;
-                } else {
-                    /* do nothing */
-                    res = r;
-                    current_block = 9120900589700563584;
-                }
-            }
-            3 => {
-                r = mailmime_read_date_parm_parse(message, length, &mut cur_token, &mut read_date);
-                if r == MAILIMF_NO_ERROR as libc::c_int {
-                    type_0 = guessed_type;
-                    current_block = 13826291924415791078;
-                } else if r == MAILIMF_ERROR_PARSE as libc::c_int {
-                    current_block = 13826291924415791078;
-                } else {
-                    /* do nothing */
-                    res = r;
-                    current_block = 9120900589700563584;
-                }
-            }
-            4 => {
-                r = mailmime_size_parm_parse(message, length, &mut cur_token, &mut size);
-                if r == MAILIMF_NO_ERROR as libc::c_int {
-                    type_0 = guessed_type;
-                    current_block = 13826291924415791078;
-                } else if r == MAILIMF_ERROR_PARSE as libc::c_int {
-                    current_block = 13826291924415791078;
-                } else {
-                    /* do nothing */
-                    res = r;
-                    current_block = 9120900589700563584;
-                }
-            }
-            _ => {
-                current_block = 13826291924415791078;
-            }
-        }
-        match current_block {
-            9120900589700563584 => {}
-            _ => {
-                if type_0 == MAILMIME_DISPOSITION_PARM_PARAMETER as libc::c_int {
-                    r = mailmime_parameter_parse(message, length, &mut cur_token, &mut parameter);
-                    if r != MAILIMF_NO_ERROR as libc::c_int {
-                        type_0 = guessed_type;
-                        res = r;
-                        current_block = 9120900589700563584;
-                    } else {
-                        current_block = 6721012065216013753;
-                    }
-                } else {
-                    current_block = 6721012065216013753;
-                }
-                match current_block {
-                    9120900589700563584 => {}
-                    _ => {
-                        dsp_parm = mailmime_disposition_parm_new(
-                            type_0,
-                            filename,
-                            creation_date,
-                            modification_date,
-                            read_date,
-                            size,
-                            parameter,
-                        );
-                        if dsp_parm.is_null() {
-                            res = MAILIMF_ERROR_MEMORY as libc::c_int;
-                            if !filename.is_null() {
-                                mailmime_filename_parm_free(filename);
-                            }
-                            if !creation_date.is_null() {
-                                mailmime_creation_date_parm_free(creation_date);
-                            }
-                            if !modification_date.is_null() {
-                                mailmime_modification_date_parm_free(modification_date);
-                            }
-                            if !read_date.is_null() {
-                                mailmime_read_date_parm_free(read_date);
-                            }
-                            if !parameter.is_null() {
-                                mailmime_parameter_free(parameter);
-                            }
-                        } else {
-                            *result = dsp_parm;
-                            *indx = cur_token;
-                            return MAILIMF_NO_ERROR as libc::c_int;
-                        }
-                    }
-                }
-            }
-        }
-    }
-    return res;
-}
-unsafe fn mailmime_size_parm_parse(
-    mut message: *const libc::c_char,
-    mut length: size_t,
-    mut indx: *mut size_t,
-    mut result: *mut size_t,
-) -> libc::c_int {
-    let mut value: uint32_t = 0;
-    let mut cur_token: size_t = 0;
-    let mut r: libc::c_int = 0;
-    cur_token = *indx;
-    r = mailimf_token_case_insensitive_len_parse(
-        message,
-        length,
-        &mut cur_token,
-        b"size\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
-        strlen(b"size\x00" as *const u8 as *const libc::c_char),
-    );
-    if r != MAILIMF_NO_ERROR as libc::c_int {
-        return r;
-    }
-    r = mailimf_unstrict_char_parse(message, length, &mut cur_token, '=' as i32 as libc::c_char);
-    if r != MAILIMF_NO_ERROR as libc::c_int {
-        return r;
-    }
-    r = mailimf_cfws_parse(message, length, &mut cur_token);
-    if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int {
-        return r;
-    }
-    r = mailimf_number_parse(message, length, &mut cur_token, &mut value);
-    if r != MAILIMF_NO_ERROR as libc::c_int {
-        return r;
-    }
-    *indx = cur_token;
-    *result = value as size_t;
-    return MAILIMF_NO_ERROR as libc::c_int;
-}
-unsafe fn mailmime_read_date_parm_parse(
-    mut message: *const libc::c_char,
-    mut length: size_t,
-    mut indx: *mut size_t,
-    mut result: *mut *mut libc::c_char,
-) -> libc::c_int {
-    let mut value: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut cur_token: size_t = 0;
-    let mut r: libc::c_int = 0;
-    cur_token = *indx;
-    r = mailimf_token_case_insensitive_len_parse(
-        message,
-        length,
-        &mut cur_token,
-        b"read-date\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
-        strlen(b"read-date\x00" as *const u8 as *const libc::c_char),
-    );
-    if r != MAILIMF_NO_ERROR as libc::c_int {
-        return r;
-    }
-    r = mailimf_unstrict_char_parse(message, length, &mut cur_token, '=' as i32 as libc::c_char);
-    if r != MAILIMF_NO_ERROR as libc::c_int {
-        return r;
-    }
-    r = mailimf_cfws_parse(message, length, &mut cur_token);
-    if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int {
-        return r;
-    }
-    r = mailmime_quoted_date_time_parse(message, length, &mut cur_token, &mut value);
-    if r != MAILIMF_NO_ERROR as libc::c_int {
-        return r;
-    }
-    *indx = cur_token;
-    *result = value;
-    return MAILIMF_NO_ERROR as libc::c_int;
-}
-unsafe fn mailmime_quoted_date_time_parse(
-    mut message: *const libc::c_char,
-    mut length: size_t,
-    mut indx: *mut size_t,
-    mut result: *mut *mut libc::c_char,
-) -> libc::c_int {
-    return mailimf_quoted_string_parse(message, length, indx, result);
-}
-unsafe fn mailmime_modification_date_parm_parse(
-    mut message: *const libc::c_char,
-    mut length: size_t,
-    mut indx: *mut size_t,
-    mut result: *mut *mut libc::c_char,
-) -> libc::c_int {
-    let mut value: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut cur_token: size_t = 0;
-    let mut r: libc::c_int = 0;
-    cur_token = *indx;
-    r = mailimf_token_case_insensitive_len_parse(
-        message,
-        length,
-        &mut cur_token,
-        b"modification-date\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
-        strlen(b"modification-date\x00" as *const u8 as *const libc::c_char),
-    );
-    if r != MAILIMF_NO_ERROR as libc::c_int {
-        return r;
-    }
-    r = mailimf_unstrict_char_parse(message, length, &mut cur_token, '=' as i32 as libc::c_char);
-    if r != MAILIMF_NO_ERROR as libc::c_int {
-        return r;
-    }
-    r = mailimf_cfws_parse(message, length, &mut cur_token);
-    if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int {
-        return r;
-    }
-    r = mailmime_quoted_date_time_parse(message, length, &mut cur_token, &mut value);
-    if r != MAILIMF_NO_ERROR as libc::c_int {
-        return r;
-    }
-    *indx = cur_token;
-    *result = value;
-    return MAILIMF_NO_ERROR as libc::c_int;
-}
-unsafe fn mailmime_creation_date_parm_parse(
-    mut message: *const libc::c_char,
-    mut length: size_t,
-    mut indx: *mut size_t,
-    mut result: *mut *mut libc::c_char,
-) -> libc::c_int {
-    let mut value: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut r: libc::c_int = 0;
-    let mut cur_token: size_t = 0;
-    cur_token = *indx;
-    r = mailimf_token_case_insensitive_len_parse(
-        message,
-        length,
-        &mut cur_token,
-        b"creation-date\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
-        strlen(b"creation-date\x00" as *const u8 as *const libc::c_char),
-    );
-    if r != MAILIMF_NO_ERROR as libc::c_int {
-        return r;
-    }
-    r = mailimf_unstrict_char_parse(message, length, &mut cur_token, '=' as i32 as libc::c_char);
-    if r != MAILIMF_NO_ERROR as libc::c_int {
-        return r;
-    }
-    r = mailimf_cfws_parse(message, length, &mut cur_token);
-    if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int {
-        return r;
-    }
-    r = mailmime_quoted_date_time_parse(message, length, &mut cur_token, &mut value);
-    if r != MAILIMF_NO_ERROR as libc::c_int {
-        return r;
-    }
-    *indx = cur_token;
-    *result = value;
-    return MAILIMF_NO_ERROR as libc::c_int;
-}
-unsafe fn mailmime_filename_parm_parse(
-    mut message: *const libc::c_char,
-    mut length: size_t,
-    mut indx: *mut size_t,
-    mut result: *mut *mut libc::c_char,
-) -> libc::c_int {
-    let mut value: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut r: libc::c_int = 0;
-    let mut cur_token: size_t = 0;
-    cur_token = *indx;
-    r = mailimf_token_case_insensitive_len_parse(
-        message,
-        length,
-        &mut cur_token,
-        b"filename\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
-        strlen(b"filename\x00" as *const u8 as *const libc::c_char),
-    );
-    if r != MAILIMF_NO_ERROR as libc::c_int {
-        return r;
-    }
-    r = mailimf_unstrict_char_parse(message, length, &mut cur_token, '=' as i32 as libc::c_char);
-    if r != MAILIMF_NO_ERROR as libc::c_int {
-        return r;
-    }
-    r = mailimf_cfws_parse(message, length, &mut cur_token);
-    if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int {
-        return r;
-    }
-    r = mailmime_value_parse(message, length, &mut cur_token, &mut value);
-    if r != MAILIMF_NO_ERROR as libc::c_int {
-        return r;
-    }
-    *indx = cur_token;
-    *result = value;
-    return MAILIMF_NO_ERROR as libc::c_int;
-}
-
-pub unsafe fn mailmime_disposition_guess_type(
-    mut message: *const libc::c_char,
-    mut length: size_t,
-    mut indx: size_t,
-) -> libc::c_int {
-    if indx >= length {
-        return MAILMIME_DISPOSITION_PARM_PARAMETER as libc::c_int;
-    }
-    match toupper(*message.offset(indx as isize) as libc::c_uchar as libc::c_int) as libc::c_char
-        as libc::c_int
-    {
-        70 => return MAILMIME_DISPOSITION_PARM_FILENAME as libc::c_int,
-        67 => return MAILMIME_DISPOSITION_PARM_CREATION_DATE as libc::c_int,
-        77 => return MAILMIME_DISPOSITION_PARM_MODIFICATION_DATE as libc::c_int,
-        82 => return MAILMIME_DISPOSITION_PARM_READ_DATE as libc::c_int,
-        83 => return MAILMIME_DISPOSITION_PARM_SIZE as libc::c_int,
-        _ => return MAILMIME_DISPOSITION_PARM_PARAMETER as libc::c_int,
-    };
-}
-
-pub unsafe fn mailmime_disposition_type_parse(
-    mut message: *const libc::c_char,
-    mut length: size_t,
-    mut indx: *mut size_t,
-    mut result: *mut *mut mailmime_disposition_type,
-) -> libc::c_int {
-    let mut cur_token: size_t = 0;
-    let mut type_0: libc::c_int = 0;
-    let mut extension: *mut libc::c_char = 0 as *mut libc::c_char;
-    let mut dsp_type: *mut mailmime_disposition_type = 0 as *mut mailmime_disposition_type;
-    let mut r: libc::c_int = 0;
-    let mut res: libc::c_int = 0;
-    cur_token = *indx;
-    r = mailimf_cfws_parse(message, length, &mut cur_token);
-    if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int {
-        res = r
-    } else {
-        type_0 = MAILMIME_DISPOSITION_TYPE_ERROR as libc::c_int;
-        extension = 0 as *mut libc::c_char;
-        r = mailimf_token_case_insensitive_len_parse(
-            message,
-            length,
-            &mut cur_token,
-            b"inline\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
-            strlen(b"inline\x00" as *const u8 as *const libc::c_char),
-        );
-        if r == MAILIMF_NO_ERROR as libc::c_int {
-            type_0 = MAILMIME_DISPOSITION_TYPE_INLINE as libc::c_int
-        }
-        if r == MAILIMF_ERROR_PARSE as libc::c_int {
-            r = mailimf_token_case_insensitive_len_parse(
-                message,
-                length,
-                &mut cur_token,
-                b"attachment\x00" as *const u8 as *const libc::c_char as *mut libc::c_char,
-                strlen(b"attachment\x00" as *const u8 as *const libc::c_char),
-            );
-            if r == MAILIMF_NO_ERROR as libc::c_int {
-                type_0 = MAILMIME_DISPOSITION_TYPE_ATTACHMENT as libc::c_int
-            }
-        }
-        if r == MAILIMF_ERROR_PARSE as libc::c_int {
-            r = mailmime_extension_token_parse(message, length, &mut cur_token, &mut extension);
-            if r == MAILIMF_NO_ERROR as libc::c_int {
-                type_0 = MAILMIME_DISPOSITION_TYPE_EXTENSION as libc::c_int
-            }
-        }
-        if r != MAILIMF_NO_ERROR as libc::c_int {
-            res = r
-        } else {
-            dsp_type = mailmime_disposition_type_new(type_0, extension);
-            if dsp_type.is_null() {
-                res = MAILIMF_ERROR_MEMORY as libc::c_int;
-                if !extension.is_null() {
-                    free(extension as *mut libc::c_void);
-                }
-            } else {
-                *result = dsp_type;
-                *indx = cur_token;
-                return MAILIMF_NO_ERROR as libc::c_int;
-            }
-        }
-    }
-    return res;
-}

mmime/src/mailmime/types.rs

@@ -1,891 +0,0 @@
-use crate::clist::*;
-use crate::mailimf::types::*;
-use crate::mmapstring::*;
-use crate::other::*;
-
-pub const MAILMIME_MECHANISM_TOKEN: libc::c_uint = 6;
-pub const MAILMIME_MECHANISM_BASE64: libc::c_uint = 5;
-pub const MAILMIME_MECHANISM_QUOTED_PRINTABLE: libc::c_uint = 4;
-pub const MAILMIME_MECHANISM_BINARY: libc::c_uint = 3;
-pub const MAILMIME_MECHANISM_8BIT: libc::c_uint = 2;
-pub const MAILMIME_MECHANISM_7BIT: libc::c_uint = 1;
-pub const MAILMIME_MECHANISM_ERROR: libc::c_uint = 0;
-
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct mailmime_composite_type {
-    pub ct_type: libc::c_int,
-    pub ct_token: *mut libc::c_char,
-}
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct mailmime_content {
-    pub ct_type: *mut mailmime_type,
-    pub ct_subtype: *mut libc::c_char,
-    pub ct_parameters: *mut clist,
-}
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct mailmime_type {
-    pub tp_type: libc::c_int,
-    pub tp_data: unnamed,
-}
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub union unnamed {
-    pub tp_discrete_type: *mut mailmime_discrete_type,
-    pub tp_composite_type: *mut mailmime_composite_type,
-}
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct mailmime_discrete_type {
-    pub dt_type: libc::c_int,
-    pub dt_extension: *mut libc::c_char,
-}
-pub type unnamed_0 = libc::c_uint;
-pub const MAILMIME_FIELD_LOCATION: unnamed_0 = 8;
-pub const MAILMIME_FIELD_LANGUAGE: unnamed_0 = 7;
-pub const MAILMIME_FIELD_DISPOSITION: unnamed_0 = 6;
-pub const MAILMIME_FIELD_VERSION: unnamed_0 = 5;
-pub const MAILMIME_FIELD_DESCRIPTION: unnamed_0 = 4;
-pub const MAILMIME_FIELD_ID: unnamed_0 = 3;
-pub const MAILMIME_FIELD_TRANSFER_ENCODING: unnamed_0 = 2;
-pub const MAILMIME_FIELD_TYPE: unnamed_0 = 1;
-pub const MAILMIME_FIELD_NONE: unnamed_0 = 0;
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct mailmime_field {
-    pub fld_type: libc::c_int,
-    pub fld_data: unnamed_1,
-}
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub union unnamed_1 {
-    pub fld_content: *mut mailmime_content,
-    pub fld_encoding: *mut mailmime_mechanism,
-    pub fld_id: *mut libc::c_char,
-    pub fld_description: *mut libc::c_char,
-    pub fld_version: uint32_t,
-    pub fld_disposition: *mut mailmime_disposition,
-    pub fld_language: *mut mailmime_language,
-    pub fld_location: *mut libc::c_char,
-}
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct mailmime_language {
-    pub lg_list: *mut clist,
-}
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct mailmime_disposition {
-    pub dsp_type: *mut mailmime_disposition_type,
-    pub dsp_parms: *mut clist,
-}
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct mailmime_disposition_type {
-    pub dsp_type: libc::c_int,
-    pub dsp_extension: *mut libc::c_char,
-}
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct mailmime_mechanism {
-    pub enc_type: libc::c_int,
-    pub enc_token: *mut libc::c_char,
-}
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct mailmime_fields {
-    pub fld_list: *mut clist,
-}
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct mailmime_parameter {
-    pub pa_name: *mut libc::c_char,
-    pub pa_value: *mut libc::c_char,
-}
-
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct mailmime_disposition_parm {
-    pub pa_type: libc::c_int,
-    pub pa_data: unnamed_3,
-}
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub union unnamed_3 {
-    pub pa_filename: *mut libc::c_char,
-    pub pa_creation_date: *mut libc::c_char,
-    pub pa_modification_date: *mut libc::c_char,
-    pub pa_read_date: *mut libc::c_char,
-    pub pa_size: size_t,
-    pub pa_parameter: *mut mailmime_parameter,
-}
-pub const MAILMIME_DISPOSITION_PARM_PARAMETER: unnamed_11 = 5;
-pub const MAILMIME_DISPOSITION_PARM_READ_DATE: unnamed_11 = 3;
-pub const MAILMIME_DISPOSITION_PARM_MODIFICATION_DATE: unnamed_11 = 2;
-pub const MAILMIME_DISPOSITION_PARM_CREATION_DATE: unnamed_11 = 1;
-pub const MAILMIME_DISPOSITION_PARM_FILENAME: unnamed_11 = 0;
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct mailmime_multipart_body {
-    pub bd_list: *mut clist,
-}
-pub type unnamed_4 = libc::c_uint;
-pub const MAILMIME_DATA_FILE: unnamed_4 = 1;
-pub const MAILMIME_DATA_TEXT: unnamed_4 = 0;
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct mailmime_data {
-    pub dt_type: libc::c_int,
-    pub dt_encoding: libc::c_int,
-    pub dt_encoded: libc::c_int,
-    pub dt_data: unnamed_5,
-}
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub union unnamed_5 {
-    pub dt_text: unnamed_6,
-    pub dt_filename: *mut libc::c_char,
-}
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct unnamed_6 {
-    pub dt_data: *const libc::c_char,
-    pub dt_length: size_t,
-}
-pub type unnamed_7 = libc::c_uint;
-pub const MAILMIME_MESSAGE: unnamed_7 = 3;
-pub const MAILMIME_MULTIPLE: unnamed_7 = 2;
-pub const MAILMIME_SINGLE: unnamed_7 = 1;
-pub const MAILMIME_NONE: unnamed_7 = 0;
-
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct Mailmime {
-    pub mm_parent_type: libc::c_int,
-    pub mm_parent: *mut Mailmime,
-    pub mm_multipart_pos: *mut clistiter,
-    pub mm_type: libc::c_int,
-    pub mm_mime_start: *const libc::c_char,
-    pub mm_length: size_t,
-    pub mm_mime_fields: *mut mailmime_fields,
-    pub mm_content_type: *mut mailmime_content,
-    pub mm_body: *mut mailmime_data,
-    pub mm_data: unnamed_8,
-}
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub union unnamed_8 {
-    pub mm_single: *mut mailmime_data,
-    pub mm_multipart: unnamed_10,
-    pub mm_message: unnamed_9,
-}
-/* message */
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct unnamed_9 {
-    pub mm_fields: *mut mailimf_fields,
-    pub mm_msg_mime: *mut Mailmime,
-}
-/* multi-part */
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct unnamed_10 {
-    pub mm_preamble: *mut mailmime_data,
-    pub mm_epilogue: *mut mailmime_data,
-    pub mm_mp_list: *mut clist,
-}
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct mailmime_encoded_word {
-    pub wd_charset: *mut libc::c_char,
-    pub wd_text: *mut libc::c_char,
-}
-pub type unnamed_11 = libc::c_uint;
-pub const MAILMIME_DISPOSITION_PARM_SIZE: unnamed_11 = 4;
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct mailmime_section {
-    pub sec_list: *mut clist,
-}
-
-pub unsafe fn mailmime_attribute_free(mut attribute: *mut libc::c_char) {
-    mailmime_token_free(attribute);
-}
-
-pub unsafe fn mailmime_token_free(mut token: *mut libc::c_char) {
-    free(token as *mut libc::c_void);
-}
-pub unsafe fn mailmime_composite_type_new(
-    mut ct_type: libc::c_int,
-    mut ct_token: *mut libc::c_char,
-) -> *mut mailmime_composite_type {
-    let mut ct: *mut mailmime_composite_type = 0 as *mut mailmime_composite_type;
-    ct = malloc(::std::mem::size_of::<mailmime_composite_type>() as libc::size_t)
-        as *mut mailmime_composite_type;
-    if ct.is_null() {
-        return 0 as *mut mailmime_composite_type;
-    }
-    (*ct).ct_type = ct_type;
-    (*ct).ct_token = ct_token;
-    return ct;
-}
-
-pub unsafe fn mailmime_composite_type_free(mut ct: *mut mailmime_composite_type) {
-    if !(*ct).ct_token.is_null() {
-        mailmime_extension_token_free((*ct).ct_token);
-    }
-    free(ct as *mut libc::c_void);
-}
-
-pub unsafe fn mailmime_extension_token_free(mut extension: *mut libc::c_char) {
-    mailmime_token_free(extension);
-}
-
-pub unsafe fn mailmime_content_new(
-    mut ct_type: *mut mailmime_type,
-    mut ct_subtype: *mut libc::c_char,
-    mut ct_parameters: *mut clist,
-) -> *mut mailmime_content {
-    let mut content: *mut mailmime_content = 0 as *mut mailmime_content;
-    content =
-        malloc(::std::mem::size_of::<mailmime_content>() as libc::size_t) as *mut mailmime_content;
-    if content.is_null() {
-        return 0 as *mut mailmime_content;
-    }
-    (*content).ct_type = ct_type;
-    (*content).ct_subtype = ct_subtype;
-    (*content).ct_parameters = ct_parameters;
-    return content;
-}
-
-pub unsafe fn mailmime_content_free(mut content: *mut mailmime_content) {
-    mailmime_type_free((*content).ct_type);
-    mailmime_subtype_free((*content).ct_subtype);
-    if !(*content).ct_parameters.is_null() {
-        clist_foreach(
-            (*content).ct_parameters,
-            ::std::mem::transmute::<Option<unsafe fn(_: *mut mailmime_parameter) -> ()>, clist_func>(
-                Some(mailmime_parameter_free),
-            ),
-            0 as *mut libc::c_void,
-        );
-        clist_free((*content).ct_parameters);
-    }
-    free(content as *mut libc::c_void);
-}
-
-pub unsafe fn mailmime_parameter_free(mut parameter: *mut mailmime_parameter) {
-    mailmime_attribute_free((*parameter).pa_name);
-    mailmime_value_free((*parameter).pa_value);
-    free(parameter as *mut libc::c_void);
-}
-
-pub unsafe fn mailmime_value_free(mut value: *mut libc::c_char) {
-    free(value as *mut libc::c_void);
-}
-
-pub unsafe fn mailmime_subtype_free(mut subtype: *mut libc::c_char) {
-    mailmime_extension_token_free(subtype);
-}
-
-pub unsafe fn mailmime_type_free(mut type_0: *mut mailmime_type) {
-    match (*type_0).tp_type {
-        1 => {
-            mailmime_discrete_type_free((*type_0).tp_data.tp_discrete_type);
-        }
-        2 => {
-            mailmime_composite_type_free((*type_0).tp_data.tp_composite_type);
-        }
-        _ => {}
-    }
-    free(type_0 as *mut libc::c_void);
-}
-
-pub unsafe fn mailmime_discrete_type_free(mut discrete_type: *mut mailmime_discrete_type) {
-    if !(*discrete_type).dt_extension.is_null() {
-        mailmime_extension_token_free((*discrete_type).dt_extension);
-    }
-    free(discrete_type as *mut libc::c_void);
-}
-
-pub unsafe fn mailmime_description_free(mut description: *mut libc::c_char) {
-    free(description as *mut libc::c_void);
-}
-
-pub unsafe fn mailmime_location_free(mut location: *mut libc::c_char) {
-    free(location as *mut libc::c_void);
-}
-
-pub unsafe fn mailmime_discrete_type_new(
-    mut dt_type: libc::c_int,
-    mut dt_extension: *mut libc::c_char,
-) -> *mut mailmime_discrete_type {
-    let mut discrete_type: *mut mailmime_discrete_type = 0 as *mut mailmime_discrete_type;
-    discrete_type = malloc(::std::mem::size_of::<mailmime_discrete_type>() as libc::size_t)
-        as *mut mailmime_discrete_type;
-    if discrete_type.is_null() {
-        return 0 as *mut mailmime_discrete_type;
-    }
-    (*discrete_type).dt_type = dt_type;
-    (*discrete_type).dt_extension = dt_extension;
-    return discrete_type;
-}
-
-pub unsafe fn mailmime_encoding_free(mut encoding: *mut mailmime_mechanism) {
-    mailmime_mechanism_free(encoding);
-}
-
-pub unsafe fn mailmime_mechanism_free(mut mechanism: *mut mailmime_mechanism) {
-    if !(*mechanism).enc_token.is_null() {
-        mailmime_token_free((*mechanism).enc_token);
-    }
-    free(mechanism as *mut libc::c_void);
-}
-
-pub unsafe fn mailmime_id_free(mut id: *mut libc::c_char) {
-    mailimf_msg_id_free(id);
-}
-
-pub unsafe fn mailmime_mechanism_new(
-    mut enc_type: libc::c_int,
-    mut enc_token: *mut libc::c_char,
-) -> *mut mailmime_mechanism {
-    let mut mechanism: *mut mailmime_mechanism = 0 as *mut mailmime_mechanism;
-    mechanism = malloc(::std::mem::size_of::<mailmime_mechanism>() as libc::size_t)
-        as *mut mailmime_mechanism;
-    if mechanism.is_null() {
-        return 0 as *mut mailmime_mechanism;
-    }
-    (*mechanism).enc_type = enc_type;
-    (*mechanism).enc_token = enc_token;
-    return mechanism;
-}
-
-pub unsafe fn mailmime_parameter_new(
-    mut pa_name: *mut libc::c_char,
-    mut pa_value: *mut libc::c_char,
-) -> *mut mailmime_parameter {
-    let mut parameter: *mut mailmime_parameter = 0 as *mut mailmime_parameter;
-    parameter = malloc(::std::mem::size_of::<mailmime_parameter>() as libc::size_t)
-        as *mut mailmime_parameter;
-    if parameter.is_null() {
-        return 0 as *mut mailmime_parameter;
-    }
-    (*parameter).pa_name = pa_name;
-    (*parameter).pa_value = pa_value;
-    return parameter;
-}
-
-pub unsafe fn mailmime_type_new(
-    mut tp_type: libc::c_int,
-    mut tp_discrete_type: *mut mailmime_discrete_type,
-    mut tp_composite_type: *mut mailmime_composite_type,
-) -> *mut mailmime_type {
-    let mut mime_type: *mut mailmime_type = 0 as *mut mailmime_type;
-    mime_type =
-        malloc(::std::mem::size_of::<mailmime_type>() as libc::size_t) as *mut mailmime_type;
-    if mime_type.is_null() {
-        return 0 as *mut mailmime_type;
-    }
-    (*mime_type).tp_type = tp_type;
-    match tp_type {
-        1 => (*mime_type).tp_data.tp_discrete_type = tp_discrete_type,
-        2 => (*mime_type).tp_data.tp_composite_type = tp_composite_type,
-        _ => {}
-    }
-    return mime_type;
-}
-
-pub unsafe fn mailmime_language_new(mut lg_list: *mut clist) -> *mut mailmime_language {
-    let mut lang: *mut mailmime_language = 0 as *mut mailmime_language;
-    lang = malloc(::std::mem::size_of::<mailmime_language>() as libc::size_t)
-        as *mut mailmime_language;
-    if lang.is_null() {
-        return 0 as *mut mailmime_language;
-    }
-    (*lang).lg_list = lg_list;
-    return lang;
-}
-
-pub unsafe fn mailmime_language_free(mut lang: *mut mailmime_language) {
-    clist_foreach(
-        (*lang).lg_list,
-        ::std::mem::transmute::<Option<unsafe fn(_: *mut libc::c_char) -> ()>, clist_func>(Some(
-            mailimf_atom_free,
-        )),
-        0 as *mut libc::c_void,
-    );
-    clist_free((*lang).lg_list);
-    free(lang as *mut libc::c_void);
-}
-/*
-void mailmime_x_token_free(gchar * x_token);
-*/
-pub unsafe fn mailmime_field_new(
-    mut fld_type: libc::c_int,
-    mut fld_content: *mut mailmime_content,
-    mut fld_encoding: *mut mailmime_mechanism,
-    mut fld_id: *mut libc::c_char,
-    mut fld_description: *mut libc::c_char,
-    mut fld_version: uint32_t,
-    mut fld_disposition: *mut mailmime_disposition,
-    mut fld_language: *mut mailmime_language,
-    mut fld_location: *mut libc::c_char,
-) -> *mut mailmime_field {
-    let mut field: *mut mailmime_field = 0 as *mut mailmime_field;
-    field = malloc(::std::mem::size_of::<mailmime_field>() as libc::size_t) as *mut mailmime_field;
-    if field.is_null() {
-        return 0 as *mut mailmime_field;
-    }
-    (*field).fld_type = fld_type;
-    match fld_type {
-        1 => (*field).fld_data.fld_content = fld_content,
-        2 => (*field).fld_data.fld_encoding = fld_encoding,
-        3 => (*field).fld_data.fld_id = fld_id,
-        4 => (*field).fld_data.fld_description = fld_description,
-        5 => (*field).fld_data.fld_version = fld_version,
-        6 => (*field).fld_data.fld_disposition = fld_disposition,
-        7 => (*field).fld_data.fld_language = fld_language,
-        8 => (*field).fld_data.fld_location = fld_location,
-        _ => {}
-    }
-    return field;
-}
-
-pub unsafe fn mailmime_field_free(mut field: *mut mailmime_field) {
-    match (*field).fld_type {
-        1 => {
-            if !(*field).fld_data.fld_content.is_null() {
-                mailmime_content_free((*field).fld_data.fld_content);
-            }
-        }
-        2 => {
-            if !(*field).fld_data.fld_encoding.is_null() {
-                mailmime_encoding_free((*field).fld_data.fld_encoding);
-            }
-        }
-        3 => {
-            if !(*field).fld_data.fld_id.is_null() {
-                mailmime_id_free((*field).fld_data.fld_id);
-            }
-        }
-        4 => {
-            if !(*field).fld_data.fld_description.is_null() {
-                mailmime_description_free((*field).fld_data.fld_description);
-            }
-        }
-        6 => {
-            if !(*field).fld_data.fld_disposition.is_null() {
-                mailmime_disposition_free((*field).fld_data.fld_disposition);
-            }
-        }
-        7 => {
-            if !(*field).fld_data.fld_language.is_null() {
-                mailmime_language_free((*field).fld_data.fld_language);
-            }
-        }
-        8 => {
-            if !(*field).fld_data.fld_location.is_null() {
-                mailmime_location_free((*field).fld_data.fld_location);
-            }
-        }
-        _ => {}
-    }
-    free(field as *mut libc::c_void);
-}
-
-pub unsafe fn mailmime_disposition_free(mut dsp: *mut mailmime_disposition) {
-    mailmime_disposition_type_free((*dsp).dsp_type);
-    clist_foreach(
-        (*dsp).dsp_parms,
-        ::std::mem::transmute::<
-            Option<unsafe fn(_: *mut mailmime_disposition_parm) -> ()>,
-            clist_func,
-        >(Some(mailmime_disposition_parm_free)),
-        0 as *mut libc::c_void,
-    );
-    clist_free((*dsp).dsp_parms);
-    free(dsp as *mut libc::c_void);
-}
-
-pub unsafe fn mailmime_disposition_parm_free(mut dsp_parm: *mut mailmime_disposition_parm) {
-    match (*dsp_parm).pa_type {
-        0 => {
-            mailmime_filename_parm_free((*dsp_parm).pa_data.pa_filename);
-        }
-        1 => {
-            mailmime_creation_date_parm_free((*dsp_parm).pa_data.pa_creation_date);
-        }
-        2 => {
-            mailmime_modification_date_parm_free((*dsp_parm).pa_data.pa_modification_date);
-        }
-        3 => {
-            mailmime_read_date_parm_free((*dsp_parm).pa_data.pa_read_date);
-        }
-        5 => {
-            mailmime_parameter_free((*dsp_parm).pa_data.pa_parameter);
-        }
-        _ => {}
-    }
-    free(dsp_parm as *mut libc::c_void);
-}
-
-pub unsafe fn mailmime_read_date_parm_free(mut date: *mut libc::c_char) {
-    mailmime_quoted_date_time_free(date);
-}
-
-pub unsafe fn mailmime_quoted_date_time_free(mut date: *mut libc::c_char) {
-    mailimf_quoted_string_free(date);
-}
-
-pub unsafe fn mailmime_modification_date_parm_free(mut date: *mut libc::c_char) {
-    mailmime_quoted_date_time_free(date);
-}
-
-pub unsafe fn mailmime_creation_date_parm_free(mut date: *mut libc::c_char) {
-    mailmime_quoted_date_time_free(date);
-}
-
-pub unsafe fn mailmime_filename_parm_free(mut filename: *mut libc::c_char) {
-    mailmime_value_free(filename);
-}
-
-pub unsafe fn mailmime_disposition_type_free(mut dsp_type: *mut mailmime_disposition_type) {
-    if !(*dsp_type).dsp_extension.is_null() {
-        free((*dsp_type).dsp_extension as *mut libc::c_void);
-    }
-    free(dsp_type as *mut libc::c_void);
-}
-
-pub unsafe fn mailmime_fields_new(mut fld_list: *mut clist) -> *mut mailmime_fields {
-    let mut fields: *mut mailmime_fields = 0 as *mut mailmime_fields;
-    fields =
-        malloc(::std::mem::size_of::<mailmime_fields>() as libc::size_t) as *mut mailmime_fields;
-    if fields.is_null() {
-        return 0 as *mut mailmime_fields;
-    }
-    (*fields).fld_list = fld_list;
-    return fields;
-}
-
-pub unsafe fn mailmime_fields_free(mut fields: *mut mailmime_fields) {
-    clist_foreach(
-        (*fields).fld_list,
-        ::std::mem::transmute::<Option<unsafe fn(_: *mut mailmime_field) -> ()>, clist_func>(Some(
-            mailmime_field_free,
-        )),
-        0 as *mut libc::c_void,
-    );
-    clist_free((*fields).fld_list);
-    free(fields as *mut libc::c_void);
-}
-
-pub unsafe fn mailmime_multipart_body_new(mut bd_list: *mut clist) -> *mut mailmime_multipart_body {
-    let mut mp_body: *mut mailmime_multipart_body = 0 as *mut mailmime_multipart_body;
-    mp_body = malloc(::std::mem::size_of::<mailmime_multipart_body>() as libc::size_t)
-        as *mut mailmime_multipart_body;
-    if mp_body.is_null() {
-        return 0 as *mut mailmime_multipart_body;
-    }
-    (*mp_body).bd_list = bd_list;
-    return mp_body;
-}
-
-pub unsafe fn mailmime_multipart_body_free(mut mp_body: *mut mailmime_multipart_body) {
-    clist_foreach(
-        (*mp_body).bd_list,
-        ::std::mem::transmute::<Option<unsafe fn(_: *mut mailimf_body) -> ()>, clist_func>(Some(
-            mailimf_body_free,
-        )),
-        0 as *mut libc::c_void,
-    );
-    clist_free((*mp_body).bd_list);
-    free(mp_body as *mut libc::c_void);
-}
-
-pub unsafe fn mailmime_data_new(
-    mut dt_type: libc::c_int,
-    mut dt_encoding: libc::c_int,
-    mut dt_encoded: libc::c_int,
-    mut dt_data: *const libc::c_char,
-    mut dt_length: size_t,
-    mut dt_filename: *mut libc::c_char,
-) -> *mut mailmime_data {
-    let mut mime_data: *mut mailmime_data = 0 as *mut mailmime_data;
-    mime_data =
-        malloc(::std::mem::size_of::<mailmime_data>() as libc::size_t) as *mut mailmime_data;
-    if mime_data.is_null() {
-        return 0 as *mut mailmime_data;
-    }
-    (*mime_data).dt_type = dt_type;
-    (*mime_data).dt_encoding = dt_encoding;
-    (*mime_data).dt_encoded = dt_encoded;
-    match dt_type {
-        0 => {
-            (*mime_data).dt_data.dt_text.dt_data = dt_data;
-            (*mime_data).dt_data.dt_text.dt_length = dt_length
-        }
-        1 => (*mime_data).dt_data.dt_filename = dt_filename,
-        _ => {}
-    }
-    return mime_data;
-}
-
-pub unsafe fn mailmime_data_free(mut mime_data: *mut mailmime_data) {
-    match (*mime_data).dt_type {
-        1 => {
-            free((*mime_data).dt_data.dt_filename as *mut libc::c_void);
-        }
-        _ => {}
-    }
-    free(mime_data as *mut libc::c_void);
-}
-
-pub unsafe fn mailmime_new(
-    mut mm_type: libc::c_int,
-    mut mm_mime_start: *const libc::c_char,
-    mut mm_length: size_t,
-    mut mm_mime_fields: *mut mailmime_fields,
-    mut mm_content_type: *mut mailmime_content,
-    mut mm_body: *mut mailmime_data,
-    mut mm_preamble: *mut mailmime_data,
-    mut mm_epilogue: *mut mailmime_data,
-    mut mm_mp_list: *mut clist,
-    mut mm_fields: *mut mailimf_fields,
-    mut mm_msg_mime: *mut Mailmime,
-) -> *mut Mailmime {
-    let mut mime: *mut Mailmime = 0 as *mut Mailmime;
-    let mut cur: *mut clistiter = 0 as *mut clistiter;
-    mime = malloc(::std::mem::size_of::<Mailmime>() as libc::size_t) as *mut Mailmime;
-    if mime.is_null() {
-        return 0 as *mut Mailmime;
-    }
-    (*mime).mm_parent = 0 as *mut Mailmime;
-    (*mime).mm_parent_type = MAILMIME_NONE as libc::c_int;
-    (*mime).mm_multipart_pos = 0 as *mut clistiter;
-    (*mime).mm_type = mm_type;
-    (*mime).mm_mime_start = mm_mime_start;
-    (*mime).mm_length = mm_length;
-    (*mime).mm_mime_fields = mm_mime_fields;
-    (*mime).mm_content_type = mm_content_type;
-    (*mime).mm_body = mm_body;
-    match mm_type {
-        1 => (*mime).mm_data.mm_single = mm_body,
-        2 => {
-            (*mime).mm_data.mm_multipart.mm_preamble = mm_preamble;
-            (*mime).mm_data.mm_multipart.mm_epilogue = mm_epilogue;
-            (*mime).mm_data.mm_multipart.mm_mp_list = mm_mp_list;
-            cur = (*mm_mp_list).first;
-            while !cur.is_null() {
-                let mut submime: *mut Mailmime = 0 as *mut Mailmime;
-                submime = (if !cur.is_null() {
-                    (*cur).data
-                } else {
-                    0 as *mut libc::c_void
-                }) as *mut Mailmime;
-                (*submime).mm_parent = mime;
-                (*submime).mm_parent_type = MAILMIME_MULTIPLE as libc::c_int;
-                (*submime).mm_multipart_pos = cur;
-                cur = if !cur.is_null() {
-                    (*cur).next
-                } else {
-                    0 as *mut clistcell
-                }
-            }
-        }
-        3 => {
-            (*mime).mm_data.mm_message.mm_fields = mm_fields;
-            (*mime).mm_data.mm_message.mm_msg_mime = mm_msg_mime;
-            if !mm_msg_mime.is_null() {
-                (*mm_msg_mime).mm_parent = mime;
-                (*mm_msg_mime).mm_parent_type = MAILMIME_MESSAGE as libc::c_int
-            }
-        }
-        _ => {}
-    }
-    return mime;
-}
-
-pub unsafe fn mailmime_new_simple(
-    mut mm_type: libc::c_int,
-    mut mm_mime_fields: *mut mailmime_fields,
-    mut mm_content_type: *mut mailmime_content,
-    mut mm_fields: *mut mailimf_fields,
-    mut mm_msg_mime: *mut Mailmime,
-) -> *mut Mailmime {
-    mailmime_new(
-        mm_type,
-        std::ptr::null(),
-        0,
-        mm_mime_fields,
-        mm_content_type,
-        std::ptr::null_mut(),
-        std::ptr::null_mut(),
-        std::ptr::null_mut(),
-        std::ptr::null_mut(),
-        mm_fields,
-        mm_msg_mime,
-    )
-}
-
-pub unsafe fn mailmime_free(mut mime: *mut Mailmime) {
-    match (*mime).mm_type {
-        1 => {
-            if (*mime).mm_body.is_null() && !(*mime).mm_data.mm_single.is_null() {
-                mailmime_data_free((*mime).mm_data.mm_single);
-            }
-        }
-        2 => {
-            /* do nothing */
-            if !(*mime).mm_data.mm_multipart.mm_preamble.is_null() {
-                mailmime_data_free((*mime).mm_data.mm_multipart.mm_preamble);
-            }
-            if !(*mime).mm_data.mm_multipart.mm_epilogue.is_null() {
-                mailmime_data_free((*mime).mm_data.mm_multipart.mm_epilogue);
-            }
-            clist_foreach(
-                (*mime).mm_data.mm_multipart.mm_mp_list,
-                ::std::mem::transmute::<Option<unsafe fn(_: *mut Mailmime) -> ()>, clist_func>(
-                    Some(mailmime_free),
-                ),
-                0 as *mut libc::c_void,
-            );
-            clist_free((*mime).mm_data.mm_multipart.mm_mp_list);
-        }
-        3 => {
-            if !(*mime).mm_data.mm_message.mm_fields.is_null() {
-                mailimf_fields_free((*mime).mm_data.mm_message.mm_fields);
-            }
-            if !(*mime).mm_data.mm_message.mm_msg_mime.is_null() {
-                mailmime_free((*mime).mm_data.mm_message.mm_msg_mime);
-            }
-        }
-        _ => {}
-    }
-    if !(*mime).mm_body.is_null() {
-        mailmime_data_free((*mime).mm_body);
-    }
-    if !(*mime).mm_mime_fields.is_null() {
-        mailmime_fields_free((*mime).mm_mime_fields);
-    }
-    if !(*mime).mm_content_type.is_null() {
-        mailmime_content_free((*mime).mm_content_type);
-    }
-    free(mime as *mut libc::c_void);
-}
-
-pub unsafe fn mailmime_encoded_word_new(
-    mut wd_charset: *mut libc::c_char,
-    mut wd_text: *mut libc::c_char,
-) -> *mut mailmime_encoded_word {
-    let mut ew: *mut mailmime_encoded_word = 0 as *mut mailmime_encoded_word;
-    ew = malloc(::std::mem::size_of::<mailmime_encoded_word>() as libc::size_t)
-        as *mut mailmime_encoded_word;
-    if ew.is_null() {
-        return 0 as *mut mailmime_encoded_word;
-    }
-    (*ew).wd_charset = wd_charset;
-    (*ew).wd_text = wd_text;
-    return ew;
-}
-
-pub unsafe fn mailmime_encoded_word_free(mut ew: *mut mailmime_encoded_word) {
-    mailmime_charset_free((*ew).wd_charset);
-    mailmime_encoded_text_free((*ew).wd_text);
-    free(ew as *mut libc::c_void);
-}
-
-pub unsafe fn mailmime_encoded_text_free(mut text: *mut libc::c_char) {
-    free(text as *mut libc::c_void);
-}
-
-pub unsafe fn mailmime_charset_free(mut charset: *mut libc::c_char) {
-    free(charset as *mut libc::c_void);
-}
-
-pub unsafe fn mailmime_disposition_new(
-    mut dsp_type: *mut mailmime_disposition_type,
-    mut dsp_parms: *mut clist,
-) -> *mut mailmime_disposition {
-    let mut dsp: *mut mailmime_disposition = 0 as *mut mailmime_disposition;
-    dsp = malloc(::std::mem::size_of::<mailmime_disposition>() as libc::size_t)
-        as *mut mailmime_disposition;
-    if dsp.is_null() {
-        return 0 as *mut mailmime_disposition;
-    }
-    (*dsp).dsp_type = dsp_type;
-    (*dsp).dsp_parms = dsp_parms;
-    return dsp;
-}
-
-pub unsafe fn mailmime_disposition_type_new(
-    mut dsp_type: libc::c_int,
-    mut dsp_extension: *mut libc::c_char,
-) -> *mut mailmime_disposition_type {
-    let mut m_dsp_type: *mut mailmime_disposition_type = 0 as *mut mailmime_disposition_type;
-    m_dsp_type = malloc(::std::mem::size_of::<mailmime_disposition_type>() as libc::size_t)
-        as *mut mailmime_disposition_type;
-    if m_dsp_type.is_null() {
-        return 0 as *mut mailmime_disposition_type;
-    }
-    (*m_dsp_type).dsp_type = dsp_type;
-    (*m_dsp_type).dsp_extension = dsp_extension;
-    return m_dsp_type;
-}
-
-pub unsafe fn mailmime_disposition_parm_new(
-    mut pa_type: libc::c_int,
-    mut pa_filename: *mut libc::c_char,
-    mut pa_creation_date: *mut libc::c_char,
-    mut pa_modification_date: *mut libc::c_char,
-    mut pa_read_date: *mut libc::c_char,
-    mut pa_size: size_t,
-    mut pa_parameter: *mut mailmime_parameter,
-) -> *mut mailmime_disposition_parm {
-    let mut dsp_parm: *mut mailmime_disposition_parm = 0 as *mut mailmime_disposition_parm;
-    dsp_parm = malloc(::std::mem::size_of::<mailmime_disposition_parm>() as libc::size_t)
-        as *mut mailmime_disposition_parm;
-    if dsp_parm.is_null() {
-        return 0 as *mut mailmime_disposition_parm;
-    }
-    (*dsp_parm).pa_type = pa_type;
-    match pa_type {
-        0 => (*dsp_parm).pa_data.pa_filename = pa_filename,
-        1 => (*dsp_parm).pa_data.pa_creation_date = pa_creation_date,
-        2 => (*dsp_parm).pa_data.pa_modification_date = pa_modification_date,
-        3 => (*dsp_parm).pa_data.pa_read_date = pa_read_date,
-        4 => (*dsp_parm).pa_data.pa_size = pa_size,
-        5 => (*dsp_parm).pa_data.pa_parameter = pa_parameter,
-        _ => {}
-    }
-    return dsp_parm;
-}
-
-pub unsafe fn mailmime_section_new(mut sec_list: *mut clist) -> *mut mailmime_section {
-    let mut section: *mut mailmime_section = 0 as *mut mailmime_section;
-    section =
-        malloc(::std::mem::size_of::<mailmime_section>() as libc::size_t) as *mut mailmime_section;
-    if section.is_null() {
-        return 0 as *mut mailmime_section;
-    }
-    (*section).sec_list = sec_list;
-    return section;
-}
-
-pub unsafe fn mailmime_section_free(mut section: *mut mailmime_section) {
-    clist_foreach(
-        (*section).sec_list,
-        ::std::mem::transmute::<Option<unsafe extern "C" fn(_: *mut libc::c_void) -> ()>, clist_func>(
-            Some(free),
-        ),
-        0 as *mut libc::c_void,
-    );
-    clist_free((*section).sec_list);
-    free(section as *mut libc::c_void);
-}
-
-pub unsafe fn mailmime_decoded_part_free(mut part: *mut libc::c_char) {
-    mmap_string_unref(part);
-}

mmime/src/mailmime/write_mem.rs

@@ -1,82 +0,0 @@
-use crate::mailmime::types::*;
-use crate::mailmime::write_generic::*;
-use crate::mmapstring::*;
-use crate::other::*;
-
-unsafe fn do_write(
-    mut data: *mut libc::c_void,
-    mut str: *const libc::c_char,
-    mut length: size_t,
-) -> libc::c_int {
-    let mut f: *mut MMAPString = 0 as *mut MMAPString;
-    f = data as *mut MMAPString;
-    if mmap_string_append_len(f, str, length).is_null() {
-        return 0i32;
-    } else {
-        return length as libc::c_int;
-    };
-}
-
-pub unsafe fn mailmime_content_write_mem(
-    mut f: *mut MMAPString,
-    mut col: *mut libc::c_int,
-    mut content: *mut mailmime_content,
-) -> libc::c_int {
-    return mailmime_content_write_driver(Some(do_write), f as *mut libc::c_void, col, content);
-}
-
-pub unsafe fn mailmime_content_type_write_mem(
-    mut f: *mut MMAPString,
-    mut col: *mut libc::c_int,
-    mut content: *mut mailmime_content,
-) -> libc::c_int {
-    return mailmime_content_type_write_driver(
-        Some(do_write),
-        f as *mut libc::c_void,
-        col,
-        content,
-    );
-}
-
-pub unsafe fn mailmime_write_mem(
-    mut f: *mut MMAPString,
-    mut col: *mut libc::c_int,
-    mut build_info: *mut Mailmime,
-) -> libc::c_int {
-    return mailmime_write_driver(Some(do_write), f as *mut libc::c_void, col, build_info);
-}
-
-pub unsafe fn mailmime_quoted_printable_write_mem(
-    mut f: *mut MMAPString,
-    mut col: *mut libc::c_int,
-    mut istext: libc::c_int,
-    mut text: *const libc::c_char,
-    mut size: size_t,
-) -> libc::c_int {
-    return mailmime_quoted_printable_write_driver(
-        Some(do_write),
-        f as *mut libc::c_void,
-        col,
-        istext,
-        text,
-        size,
-    );
-}
-
-pub unsafe fn mailmime_base64_write_mem(
-    mut f: *mut MMAPString,
-    mut col: *mut libc::c_int,
-    mut text: *const libc::c_char,
-    mut size: size_t,
-) -> libc::c_int {
-    return mailmime_base64_write_driver(Some(do_write), f as *mut libc::c_void, col, text, size);
-}
-
-pub unsafe fn mailmime_data_write_mem(
-    mut f: *mut MMAPString,
-    mut col: *mut libc::c_int,
-    mut data: *mut mailmime_data,
-    mut istext: libc::c_int,
-) -> libc::c_int {
-    return mailmime_data_write_driver(Some(do_write), f as *mut libc::c_void, col, data, istext);
-}

mmime/src/mmapstring.rs

@@ -1,397 +0,0 @@
-use std::sync::Mutex;
-
-use lazy_static::lazy_static;
-use libc;
-
-use crate::chash::*;
-use crate::other::*;
-
-lazy_static! {
-    static ref mmapstring_lock: Mutex<()> = Mutex::new(());
-}
-
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct MMAPString {
-    pub str_0: *mut libc::c_char,
-    pub len: size_t,
-    pub allocated_len: size_t,
-    pub fd: libc::c_int,
-    pub mmapped_size: size_t,
-}
-
-pub const TMPDIR: &'static str = "/tmp";
-
-pub unsafe fn mmap_string_new(mut init: *const libc::c_char) -> *mut MMAPString {
-    let mut string: *mut MMAPString = 0 as *mut MMAPString;
-    string = mmap_string_sized_new(if !init.is_null() {
-        strlen(init).wrapping_add(2i32 as libc::size_t)
-    } else {
-        2i32 as libc::size_t
-    });
-    if string.is_null() {
-        return 0 as *mut MMAPString;
-    }
-    if !init.is_null() {
-        mmap_string_append(string, init);
-    }
-    return string;
-}
-
-pub unsafe fn mmap_string_append(
-    mut string: *mut MMAPString,
-    mut val: *const libc::c_char,
-) -> *mut MMAPString {
-    return mmap_string_insert_len(string, (*string).len, val, strlen(val));
-}
-
-pub unsafe fn mmap_string_insert_len(
-    mut string: *mut MMAPString,
-    mut pos: size_t,
-    mut val: *const libc::c_char,
-    mut len: size_t,
-) -> *mut MMAPString {
-    if mmap_string_maybe_expand(string, len).is_null() {
-        return 0 as *mut MMAPString;
-    }
-    if pos < (*string).len {
-        memmove(
-            (*string).str_0.offset(pos as isize).offset(len as isize) as *mut libc::c_void,
-            (*string).str_0.offset(pos as isize) as *const libc::c_void,
-            (*string).len.wrapping_sub(pos),
-        );
-    }
-    memmove(
-        (*string).str_0.offset(pos as isize) as *mut libc::c_void,
-        val as *const libc::c_void,
-        len,
-    );
-    (*string).len = ((*string).len as libc::size_t).wrapping_add(len) as size_t as size_t;
-    *(*string).str_0.offset((*string).len as isize) = 0i32 as libc::c_char;
-    return string;
-}
-unsafe fn mmap_string_maybe_expand(
-    mut string: *mut MMAPString,
-    mut len: size_t,
-) -> *mut MMAPString {
-    if (*string).len.wrapping_add(len) >= (*string).allocated_len {
-        let mut old_size: size_t = 0;
-        let mut newstring: *mut MMAPString = 0 as *mut MMAPString;
-        old_size = (*string).allocated_len;
-        (*string).allocated_len = nearest_power(
-            1i32 as size_t,
-            (*string)
-                .len
-                .wrapping_add(len)
-                .wrapping_add(1i32 as libc::size_t),
-        );
-        newstring = mmap_string_realloc_memory(string);
-        if newstring.is_null() {
-            (*string).allocated_len = old_size
-        }
-        return newstring;
-    }
-    return string;
-}
-/* Strings.
- */
-/* SEB */
-unsafe fn mmap_string_realloc_memory(mut string: *mut MMAPString) -> *mut MMAPString {
-    let mut tmp: *mut libc::c_char = 0 as *mut libc::c_char;
-    tmp = realloc(
-        (*string).str_0 as *mut libc::c_void,
-        (*string).allocated_len,
-    ) as *mut libc::c_char;
-    if tmp.is_null() {
-        string = 0 as *mut MMAPString
-    } else {
-        (*string).str_0 = tmp
-    }
-    return string;
-}
-/* MMAPString */
-#[inline]
-unsafe fn nearest_power(mut base: size_t, mut num: size_t) -> size_t {
-    if num > (-1i32 as size_t).wrapping_div(2i32 as libc::size_t) {
-        return -1i32 as size_t;
-    } else {
-        let mut n: size_t = base;
-        while n < num {
-            n <<= 1i32
-        }
-        return n;
-    };
-}
-
-pub unsafe fn mmap_string_sized_new(mut dfl_size: size_t) -> *mut MMAPString {
-    let mut string: *mut MMAPString = 0 as *mut MMAPString;
-    string = malloc(::std::mem::size_of::<MMAPString>() as libc::size_t) as *mut MMAPString;
-    if string.is_null() {
-        return 0 as *mut MMAPString;
-    }
-    (*string).allocated_len = 0i32 as size_t;
-    (*string).len = 0i32 as size_t;
-    (*string).str_0 = 0 as *mut libc::c_char;
-    (*string).fd = -1i32;
-    (*string).mmapped_size = 0i32 as size_t;
-    if mmap_string_maybe_expand(
-        string,
-        if dfl_size > 2i32 as libc::size_t {
-            dfl_size
-        } else {
-            2i32 as libc::size_t
-        },
-    )
-    .is_null()
-    {
-        free(string as *mut libc::c_void);
-        return 0 as *mut MMAPString;
-    }
-    *(*string).str_0.offset(0isize) = 0i32 as libc::c_char;
-    return string;
-}
-
-pub unsafe fn mmap_string_new_len(
-    mut init: *const libc::c_char,
-    mut len: size_t,
-) -> *mut MMAPString {
-    let mut string: *mut MMAPString = 0 as *mut MMAPString;
-    if len <= 0i32 as libc::size_t {
-        return mmap_string_new(b"\x00" as *const u8 as *const libc::c_char);
-    } else {
-        string = mmap_string_sized_new(len);
-        if string.is_null() {
-            return string;
-        }
-        if !init.is_null() {
-            mmap_string_append_len(string, init, len);
-        }
-        return string;
-    };
-}
-
-pub unsafe fn mmap_string_append_len(
-    mut string: *mut MMAPString,
-    mut val: *const libc::c_char,
-    mut len: size_t,
-) -> *mut MMAPString {
-    return mmap_string_insert_len(string, (*string).len, val, len);
-}
-
-pub unsafe fn mmap_string_free(mut string: *mut MMAPString) {
-    if string.is_null() {
-        return;
-    }
-    free((*string).str_0 as *mut libc::c_void);
-    free(string as *mut libc::c_void);
-}
-
-pub unsafe fn mmap_string_assign(
-    mut string: *mut MMAPString,
-    mut rval: *const libc::c_char,
-) -> *mut MMAPString {
-    mmap_string_truncate(string, 0i32 as size_t);
-    if mmap_string_append(string, rval).is_null() {
-        return 0 as *mut MMAPString;
-    }
-    return string;
-}
-
-pub unsafe fn mmap_string_truncate(
-    mut string: *mut MMAPString,
-    mut len: size_t,
-) -> *mut MMAPString {
-    (*string).len = if len < (*string).len {
-        len
-    } else {
-        (*string).len
-    };
-    *(*string).str_0.offset((*string).len as isize) = 0i32 as libc::c_char;
-    return string;
-}
-
-pub unsafe fn mmap_string_set_size(
-    mut string: *mut MMAPString,
-    mut len: size_t,
-) -> *mut MMAPString {
-    if len >= (*string).allocated_len {
-        if mmap_string_maybe_expand(string, len.wrapping_sub((*string).len)).is_null() {
-            return 0 as *mut MMAPString;
-        }
-    }
-    (*string).len = len;
-    *(*string).str_0.offset(len as isize) = 0i32 as libc::c_char;
-    return string;
-}
-
-pub unsafe fn mmap_string_append_c(
-    mut string: *mut MMAPString,
-    mut c: libc::c_char,
-) -> *mut MMAPString {
-    return mmap_string_insert_c(string, (*string).len, c);
-}
-
-pub unsafe fn mmap_string_insert_c(
-    mut string: *mut MMAPString,
-    mut pos: size_t,
-    mut c: libc::c_char,
-) -> *mut MMAPString {
-    if mmap_string_maybe_expand(string, 1i32 as size_t).is_null() {
-        return 0 as *mut MMAPString;
-    }
-    if pos < (*string).len {
-        memmove(
-            (*string).str_0.offset(pos as isize).offset(1isize) as *mut libc::c_void,
-            (*string).str_0.offset(pos as isize) as *const libc::c_void,
-            (*string).len.wrapping_sub(pos),
-        );
-    }
-    *(*string).str_0.offset(pos as isize) = c;
-    (*string).len =
-        ((*string).len as libc::size_t).wrapping_add(1i32 as libc::size_t) as size_t as size_t;
-    *(*string).str_0.offset((*string).len as isize) = 0i32 as libc::c_char;
-    return string;
-}
-
-pub unsafe fn mmap_string_prepend(
-    mut string: *mut MMAPString,
-    mut val: *const libc::c_char,
-) -> *mut MMAPString {
-    return mmap_string_insert_len(string, 0i32 as size_t, val, strlen(val));
-}
-
-pub unsafe fn mmap_string_prepend_c(
-    mut string: *mut MMAPString,
-    mut c: libc::c_char,
-) -> *mut MMAPString {
-    return mmap_string_insert_c(string, 0i32 as size_t, c);
-}
-
-pub unsafe fn mmap_string_prepend_len(
-    mut string: *mut MMAPString,
-    mut val: *const libc::c_char,
-    mut len: size_t,
-) -> *mut MMAPString {
-    return mmap_string_insert_len(string, 0i32 as size_t, val, len);
-}
-
-pub unsafe fn mmap_string_insert(
-    mut string: *mut MMAPString,
-    mut pos: size_t,
-    mut val: *const libc::c_char,
-) -> *mut MMAPString {
-    return mmap_string_insert_len(string, pos, val, strlen(val));
-}
-
-pub unsafe fn mmap_string_erase(
-    mut string: *mut MMAPString,
-    mut pos: size_t,
-    mut len: size_t,
-) -> *mut MMAPString {
-    if pos.wrapping_add(len) < (*string).len {
-        memmove(
-            (*string).str_0.offset(pos as isize) as *mut libc::c_void,
-            (*string).str_0.offset(pos as isize).offset(len as isize) as *const libc::c_void,
-            (*string).len.wrapping_sub(pos.wrapping_add(len)),
-        );
-    }
-    (*string).len = ((*string).len as libc::size_t).wrapping_sub(len) as size_t as size_t;
-    *(*string).str_0.offset((*string).len as isize) = 0i32 as libc::c_char;
-    return string;
-}
-
-pub unsafe fn mmap_string_set_ceil(mut ceil: size_t) {
-    mmap_string_ceil = ceil;
-}
-static mut mmap_string_ceil: size_t = (8i32 * 1024i32 * 1024i32) as size_t;
-
-pub unsafe fn mmap_string_ref(mut string: *mut MMAPString) -> libc::c_int {
-    let mut ht: *mut chash = 0 as *mut chash;
-    let mut r: libc::c_int = 0;
-    let mut key: chashdatum = chashdatum {
-        data: 0 as *mut libc::c_void,
-        len: 0,
-    };
-    let mut data: chashdatum = chashdatum {
-        data: 0 as *mut libc::c_void,
-        len: 0,
-    };
-    mmapstring_lock.lock().unwrap();
-    if mmapstring_hashtable.is_null() {
-        mmapstring_hashtable_init();
-    }
-    ht = mmapstring_hashtable;
-    if ht.is_null() {
-        return -1i32;
-    }
-    key.data = &mut (*string).str_0 as *mut *mut libc::c_char as *mut libc::c_void;
-    key.len = ::std::mem::size_of::<*mut libc::c_char>() as libc::size_t as libc::c_uint;
-    data.data = string as *mut libc::c_void;
-    data.len = 0i32 as libc::c_uint;
-    r = chash_set(
-        mmapstring_hashtable,
-        &mut key,
-        &mut data,
-        0 as *mut chashdatum,
-    );
-
-    if r < 0i32 {
-        return r;
-    }
-    return 0i32;
-}
-
-static mut mmapstring_hashtable: *mut chash = 0 as *const chash as *mut chash;
-unsafe fn mmapstring_hashtable_init() {
-    mmapstring_hashtable = chash_new(13i32 as libc::c_uint, 1i32);
-}
-
-pub unsafe fn mmap_string_unref(mut str: *mut libc::c_char) -> libc::c_int {
-    let mut string: *mut MMAPString = 0 as *mut MMAPString;
-    let mut ht: *mut chash = 0 as *mut chash;
-    let mut key: chashdatum = chashdatum {
-        data: 0 as *mut libc::c_void,
-        len: 0,
-    };
-    let mut data: chashdatum = chashdatum {
-        data: 0 as *mut libc::c_void,
-        len: 0,
-    };
-    let mut r: libc::c_int = 0;
-    if str.is_null() {
-        return -1i32;
-    }
-    mmapstring_lock.lock().unwrap();
-    ht = mmapstring_hashtable;
-    if ht.is_null() {
-        return -1i32;
-    }
-    key.data = &mut str as *mut *mut libc::c_char as *mut libc::c_void;
-    key.len = ::std::mem::size_of::<*mut libc::c_char>() as libc::size_t as libc::c_uint;
-    r = chash_get(ht, &mut key, &mut data);
-    if r < 0i32 {
-        string = 0 as *mut MMAPString
-    } else {
-        string = data.data as *mut MMAPString
-    }
-    if !string.is_null() {
-        chash_delete(ht, &mut key, 0 as *mut chashdatum);
-        if chash_count(ht) == 0i32 as libc::c_uint {
-            chash_free(ht);
-            mmapstring_hashtable = 0 as *mut chash
-        }
-    }
-    if !string.is_null() {
-        mmap_string_free(string);
-        return 0i32;
-    } else {
-        return -1i32;
-    };
-}
-#[inline]
-unsafe fn chash_count(mut hash: *mut chash) -> libc::c_uint {
-    return (*hash).count;
-}
-
-pub unsafe fn mmapstring_init_lock() {}
-pub unsafe fn mmapstring_uninit_lock() {}

python/src/deltachat/message.py

@@ -162,7 +162,7 @@ class Message(object):
         if mime_headers:
             s = ffi.string(ffi.gc(mime_headers, lib.dc_str_unref))
             if isinstance(s, bytes):
-                s = s.decode("ascii")
+                return email.message_from_bytes(s)
             return email.message_from_string(s)
 
     @property

python/tests/test_account.py

@@ -794,6 +794,7 @@ class TestOnlineAccount:
         chat2 = ac2.qr_join_chat(qr)
         assert chat2.id >= 10
         wait_securejoin_inviter_progress(ac1, 1000)
+        ac1._evlogger.get_matching("DC_EVENT_SECUREJOIN_MEMBER_ADDED")
 
         lp.sec("ac2: read member added message")
         msg = ac2.wait_next_incoming_message()

src/aheader.rs

@@ -3,14 +3,12 @@
 //! Parse and create [Autocrypt-headers](https://autocrypt.org/en/latest/level1.html#the-autocrypt-header).
 
 use std::collections::BTreeMap;
-use std::ffi::CStr;
 use std::str::FromStr;
 use std::{fmt, str};
 
-use mmime::mailimf::types::*;
-
 use crate::constants::*;
 use crate::contact::*;
+use crate::context::Context;
 use crate::key::*;
 
 /// Possible values for encryption preference
@@ -44,8 +42,8 @@ impl str::FromStr for EncryptPreference {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
             "mutual" => Ok(EncryptPreference::Mutual),
-            "reset" => Ok(EncryptPreference::Reset),
-            _ => Ok(EncryptPreference::NoPreference),
+            "nopreference" => Ok(EncryptPreference::NoPreference),
+            _ => Err(()),
         }
     }
 }
@@ -68,45 +66,31 @@ impl Aheader {
         }
     }
 
-    pub fn from_imffields(wanted_from: &str, header: *const mailimf_fields) -> Option<Self> {
-        if header.is_null() {
-            return None;
-        }
+    pub fn from_headers(
+        context: &Context,
+        wanted_from: &str,
+        headers: &[mailparse::MailHeader<'_>],
+    ) -> Option<Self> {
+        use mailparse::MailHeaderMap;
 
-        let mut fine_header = None;
-        let mut cur = unsafe { (*(*header).fld_list).first };
-
-        while !cur.is_null() {
-            let field = unsafe { (*cur).data as *mut mailimf_field };
-            if !field.is_null()
-                && unsafe { (*field).fld_type } == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int
-            {
-                let optional_field = unsafe { (*field).fld_data.fld_optional_field };
-                if !optional_field.is_null()
-                    && unsafe { !(*optional_field).fld_name.is_null() }
-                    && unsafe { CStr::from_ptr((*optional_field).fld_name).to_string_lossy() }
-                        == "Autocrypt"
-                {
-                    let value =
-                        unsafe { CStr::from_ptr((*optional_field).fld_value).to_string_lossy() };
-
-                    if let Ok(test) = Self::from_str(&value) {
-                        if addr_cmp(&test.addr, wanted_from) {
-                            if fine_header.is_none() {
-                                fine_header = Some(test);
-                            } else {
-                                // TODO: figure out what kind of error case this is
-                                return None;
-                            }
-                        }
+        if let Ok(Some(value)) = headers.get_first_value("Autocrypt") {
+            match Self::from_str(&value) {
+                Ok(header) => {
+                    info!(context, "comparing {} - {}", header.addr, wanted_from);
+                    if addr_cmp(&header.addr, wanted_from) {
+                        return Some(header);
                     }
                 }
+                Err(err) => {
+                    warn!(
+                        context,
+                        "found invalid autocrypt header {}: {:?}", value, err
+                    );
+                }
             }
-
-            cur = unsafe { (*cur).next };
         }
 
-        fine_header
+        None
     }
 }
 

src/blob.rs

@@ -32,11 +32,11 @@ impl<'a> BlobObject<'a> {
     ///
     /// # Errors
     ///
-    /// [BlobErrorKind::CreateFailure] is used when the file could not
+    /// [BlobError::CreateFailure] is used when the file could not
     /// be created.  You can expect [BlobError.cause] to contain an
     /// underlying error.
     ///
-    /// [BlobErrorKind::WriteFailure] is used when the file could not
+    /// [BlobError::WriteFailure] is used when the file could not
     /// be written to.  You can expect [BlobError.cause] to contain an
     /// underlying error.
     pub fn create(
@@ -48,7 +48,12 @@ impl<'a> BlobObject<'a> {
         let (stem, ext) = BlobObject::sanitise_name(suggested_name.as_ref());
         let (name, mut file) = BlobObject::create_new_file(&blobdir, &stem, &ext)?;
         file.write_all(data)
-            .map_err(|err| BlobError::new_write_failure(blobdir, &name, err))?;
+            .map_err(|err| BlobError::WriteFailure {
+                blobdir: blobdir.to_path_buf(),
+                blobname: name.clone(),
+                cause: err,
+                backtrace: failure::Backtrace::new(),
+            })?;
         let blob = BlobObject {
             blobdir,
             name: format!("$BLOBDIR/{}", name),
@@ -71,18 +76,25 @@ impl<'a> BlobObject<'a> {
                 Ok(file) => return Ok((name, file)),
                 Err(err) => {
                     if attempt == max_attempt {
-                        return Err(BlobError::new_create_failure(dir, &name, err));
+                        return Err(BlobError::CreateFailure {
+                            blobdir: dir.to_path_buf(),
+                            blobname: name,
+                            cause: err,
+                            backtrace: failure::Backtrace::new(),
+                        });
                     } else {
                         name = format!("{}-{}{}", stem, rand::random::<u32>(), ext);
                     }
                 }
             }
         }
-        Err(BlobError::new_create_failure(
-            dir,
-            &name,
-            format_err!("Unreachable code - supposedly"),
-        ))
+        // This is supposed to be unreachable, but the compiler doesn't know.
+        Err(BlobError::CreateFailure {
+            blobdir: dir.to_path_buf(),
+            blobname: name,
+            cause: std::io::Error::new(std::io::ErrorKind::Other, "supposedly unreachable"),
+            backtrace: failure::Backtrace::new(),
+        })
     }
 
     /// Creates a new blob object with unique name by copying an existing file.
@@ -95,24 +107,35 @@ impl<'a> BlobObject<'a> {
     /// # Errors
     ///
     /// In addition to the errors in [BlobObject::create] the
-    /// [BlobErrorKind::CopyFailure] is used when the data can not be
+    /// [BlobError::CopyFailure] is used when the data can not be
     /// copied.
     pub fn create_and_copy(
         context: &'a Context,
         src: impl AsRef<Path>,
     ) -> std::result::Result<BlobObject<'a>, BlobError> {
-        let mut src_file = fs::File::open(src.as_ref()).map_err(|err| {
-            BlobError::new_copy_failure(context.get_blobdir(), "", src.as_ref(), err)
+        let mut src_file = fs::File::open(src.as_ref()).map_err(|err| BlobError::CopyFailure {
+            blobdir: context.get_blobdir().to_path_buf(),
+            blobname: String::from(""),
+            src: src.as_ref().to_path_buf(),
+            cause: err,
+            backtrace: failure::Backtrace::new(),
         })?;
         let (stem, ext) = BlobObject::sanitise_name(&src.as_ref().to_string_lossy());
         let (name, mut dst_file) = BlobObject::create_new_file(context.get_blobdir(), &stem, &ext)?;
+        let name_for_err = name.clone();
         std::io::copy(&mut src_file, &mut dst_file).map_err(|err| {
             {
                 // Attempt to remove the failed file, swallow errors resulting from that.
-                let path = context.get_blobdir().join(&name);
+                let path = context.get_blobdir().join(&name_for_err);
                 fs::remove_file(path).ok();
             }
-            BlobError::new_copy_failure(context.get_blobdir(), &name, src.as_ref(), err)
+            BlobError::CopyFailure {
+                blobdir: context.get_blobdir().to_path_buf(),
+                blobname: name_for_err,
+                src: src.as_ref().to_path_buf(),
+                cause: err,
+                backtrace: failure::Backtrace::new(),
+            }
         })?;
         let blob = BlobObject {
             blobdir: context.get_blobdir(),
@@ -156,10 +179,10 @@ impl<'a> BlobObject<'a> {
     ///
     /// # Errors
     ///
-    /// [BlobErrorKind::WrongBlobdir] is used if the path is not in
+    /// [BlobError::WrongBlobdir] is used if the path is not in
     /// the blob directory.
     ///
-    /// [BlobErrorKind::WrongName] is used if the file name does not
+    /// [BlobError::WrongName] is used if the file name does not
     /// remain identical after sanitisation.
     pub fn from_path(
         context: &Context,
@@ -168,13 +191,21 @@ impl<'a> BlobObject<'a> {
         let rel_path = path
             .as_ref()
             .strip_prefix(context.get_blobdir())
-            .map_err(|_| BlobError::new_wrong_blobdir(context.get_blobdir(), path.as_ref()))?;
+            .map_err(|_| BlobError::WrongBlobdir {
+                blobdir: context.get_blobdir().to_path_buf(),
+                src: path.as_ref().to_path_buf(),
+                backtrace: failure::Backtrace::new(),
+            })?;
         if !BlobObject::is_acceptible_blob_name(&rel_path) {
-            return Err(BlobError::new_wrong_name(path.as_ref()));
+            return Err(BlobError::WrongName {
+                blobname: path.as_ref().to_path_buf(),
+                backtrace: failure::Backtrace::new(),
+            });
         }
-        let name = rel_path
-            .to_str()
-            .ok_or_else(|| BlobError::new_wrong_name(path.as_ref()))?;
+        let name = rel_path.to_str().ok_or_else(|| BlobError::WrongName {
+            blobname: path.as_ref().to_path_buf(),
+            backtrace: failure::Backtrace::new(),
+        })?;
         BlobObject::from_name(context, name.to_string())
     }
 
@@ -187,7 +218,7 @@ impl<'a> BlobObject<'a> {
     ///
     /// # Errors
     ///
-    /// [BlobErrorKind::WrongName] is used if the name is not a valid
+    /// [BlobError::WrongName] is used if the name is not a valid
     /// blobname, i.e. if [BlobObject::sanitise_name] does modify the
     /// provided name.
     pub fn from_name(
@@ -199,7 +230,10 @@ impl<'a> BlobObject<'a> {
             false => name,
         };
         if !BlobObject::is_acceptible_blob_name(&name) {
-            return Err(BlobError::new_wrong_name(name));
+            return Err(BlobError::WrongName {
+                blobname: PathBuf::from(name),
+                backtrace: failure::Backtrace::new(),
+            });
         }
         Ok(BlobObject {
             blobdir: context.get_blobdir(),
@@ -324,171 +358,50 @@ impl<'a> fmt::Display for BlobObject<'a> {
 }
 
 /// Errors for the [BlobObject].
-///
-/// To keep the return type small and thus the happy path fast this
-/// stores everything on the heap.
-#[derive(Debug)]
-pub struct BlobError {
-    inner: Box<BlobErrorInner>,
-}
-
-#[derive(Debug)]
-struct BlobErrorInner {
-    kind: BlobErrorKind,
-    data: BlobErrorData,
-    backtrace: failure::Backtrace,
-}
-
-/// Error kind for [BlobError].
-///
-/// Each error kind has associated data in the [BlobErrorData].
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum BlobErrorKind {
-    /// Failed to create the blob.
-    CreateFailure,
-    /// Failed to write data to blob.
-    WriteFailure,
-    /// Failed to copy data to blob.
-    CopyFailure,
-    /// Blob is not in the blobdir.
-    WrongBlobdir,
-    /// Blob has a bad name.
-    ///
-    /// E.g. the name is not sanitised correctly or contains a
-    /// sub-directory.
-    WrongName,
-}
-
-/// Associated data for each [BlobError] error kind.
-///
-/// This is not stored directly on the [BlobErrorKind] so that the
-/// kind can stay trivially Copy and Eq.  It is however possible to
-/// create a [BlobError] with mismatching [BlobErrorKind] and
-/// [BlobErrorData], don't do that.
-///
-/// Any blobname stored here is the bare name, without the `$BLOBDIR`
-/// prefix.  All data is owned so that errors do not need to be tied
-/// to any lifetimes.
-#[derive(Debug)]
-enum BlobErrorData {
+#[derive(Fail, Debug)]
+pub enum BlobError {
     CreateFailure {
         blobdir: PathBuf,
         blobname: String,
-        cause: failure::Error,
+        #[cause]
+        cause: std::io::Error,
+        backtrace: failure::Backtrace,
     },
     WriteFailure {
         blobdir: PathBuf,
         blobname: String,
-        cause: failure::Error,
+        #[cause]
+        cause: std::io::Error,
+        backtrace: failure::Backtrace,
     },
     CopyFailure {
         blobdir: PathBuf,
         blobname: String,
         src: PathBuf,
-        cause: failure::Error,
+        #[cause]
+        cause: std::io::Error,
+        backtrace: failure::Backtrace,
     },
     WrongBlobdir {
         blobdir: PathBuf,
         src: PathBuf,
+        backtrace: failure::Backtrace,
     },
     WrongName {
         blobname: PathBuf,
+        backtrace: failure::Backtrace,
     },
 }
 
-impl BlobError {
-    pub fn kind(&self) -> BlobErrorKind {
-        self.inner.kind
-    }
-
-    fn new_create_failure(
-        blobdir: impl Into<PathBuf>,
-        blobname: impl Into<String>,
-        cause: impl Into<failure::Error>,
-    ) -> BlobError {
-        BlobError {
-            inner: Box::new(BlobErrorInner {
-                kind: BlobErrorKind::CreateFailure,
-                data: BlobErrorData::CreateFailure {
-                    blobdir: blobdir.into(),
-                    blobname: blobname.into(),
-                    cause: cause.into(),
-                },
-                backtrace: failure::Backtrace::new(),
-            }),
-        }
-    }
-
-    fn new_write_failure(
-        blobdir: impl Into<PathBuf>,
-        blobname: impl Into<String>,
-        cause: impl Into<failure::Error>,
-    ) -> BlobError {
-        BlobError {
-            inner: Box::new(BlobErrorInner {
-                kind: BlobErrorKind::WriteFailure,
-                data: BlobErrorData::WriteFailure {
-                    blobdir: blobdir.into(),
-                    blobname: blobname.into(),
-                    cause: cause.into(),
-                },
-                backtrace: failure::Backtrace::new(),
-            }),
-        }
-    }
-
-    fn new_copy_failure(
-        blobdir: impl Into<PathBuf>,
-        blobname: impl Into<String>,
-        src: impl Into<PathBuf>,
-        cause: impl Into<failure::Error>,
-    ) -> BlobError {
-        BlobError {
-            inner: Box::new(BlobErrorInner {
-                kind: BlobErrorKind::CopyFailure,
-                data: BlobErrorData::CopyFailure {
-                    blobdir: blobdir.into(),
-                    blobname: blobname.into(),
-                    src: src.into(),
-                    cause: cause.into(),
-                },
-                backtrace: failure::Backtrace::new(),
-            }),
-        }
-    }
-
-    fn new_wrong_blobdir(blobdir: impl Into<PathBuf>, src: impl Into<PathBuf>) -> BlobError {
-        BlobError {
-            inner: Box::new(BlobErrorInner {
-                kind: BlobErrorKind::WrongBlobdir,
-                data: BlobErrorData::WrongBlobdir {
-                    blobdir: blobdir.into(),
-                    src: src.into(),
-                },
-                backtrace: failure::Backtrace::new(),
-            }),
-        }
-    }
-
-    fn new_wrong_name(blobname: impl Into<PathBuf>) -> BlobError {
-        BlobError {
-            inner: Box::new(BlobErrorInner {
-                kind: BlobErrorKind::WrongName,
-                data: BlobErrorData::WrongName {
-                    blobname: blobname.into(),
-                },
-                backtrace: failure::Backtrace::new(),
-            }),
-        }
-    }
-}
-
+// Implementing Display is done by hand because the failure
+// #[fail(display = "...")] syntax does not allow using
+// `blobdir.display()`.
 impl fmt::Display for BlobError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         // Match on the data rather than kind, they are equivalent for
         // identifying purposes but contain the actual data we need.
-        match &self.inner.data {
-            BlobErrorData::CreateFailure {
+        match &self {
+            BlobError::CreateFailure {
                 blobdir, blobname, ..
             } => write!(
                 f,
@@ -496,7 +409,7 @@ impl fmt::Display for BlobError {
                 blobname,
                 blobdir.display()
             ),
-            BlobErrorData::WriteFailure {
+            BlobError::WriteFailure {
                 blobdir, blobname, ..
             } => write!(
                 f,
@@ -504,7 +417,7 @@ impl fmt::Display for BlobError {
                 blobname,
                 blobdir.display()
             ),
-            BlobErrorData::CopyFailure {
+            BlobError::CopyFailure {
                 blobdir,
                 blobname,
                 src,
@@ -516,34 +429,19 @@ impl fmt::Display for BlobError {
                 blobname,
                 blobdir.display(),
             ),
-            BlobErrorData::WrongBlobdir { blobdir, src } => write!(
+            BlobError::WrongBlobdir { blobdir, src, .. } => write!(
                 f,
                 "File path {} is not in blobdir {}",
                 src.display(),
                 blobdir.display(),
             ),
-            BlobErrorData::WrongName { blobname } => {
+            BlobError::WrongName { blobname, .. } => {
                 write!(f, "Blob has a bad name: {}", blobname.display(),)
             }
         }
     }
 }
 
-impl failure::Fail for BlobError {
-    fn cause(&self) -> Option<&dyn failure::Fail> {
-        match &self.inner.data {
-            BlobErrorData::CreateFailure { cause, .. }
-            | BlobErrorData::WriteFailure { cause, .. }
-            | BlobErrorData::CopyFailure { cause, .. } => Some(cause.as_fail()),
-            _ => None,
-        }
-    }
-
-    fn backtrace(&self) -> Option<&failure::Backtrace> {
-        Some(&self.inner.backtrace)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/chat.rs

@@ -5,18 +5,18 @@ use std::path::{Path, PathBuf};
 use itertools::Itertools;
 use num_traits::FromPrimitive;
 
-use crate::blob::{BlobErrorKind, BlobObject};
+use crate::blob::{BlobError, BlobObject};
 use crate::chatlist::*;
 use crate::config::*;
 use crate::constants::*;
 use crate::contact::*;
 use crate::context::Context;
-use crate::dc_mimeparser::SystemMessage;
 use crate::dc_tools::*;
 use crate::error::Error;
 use crate::events::Event;
 use crate::job::*;
 use crate::message::{self, InvalidMsgId, Message, MessageState, MsgId};
+use crate::mimeparser::SystemMessage;
 use crate::param::*;
 use crate::sql::{self, Sql};
 use crate::stock::StockMessage;
@@ -64,13 +64,15 @@ impl Chat {
         );
 
         match res {
-            Err(err @ crate::error::Error::Sql(rusqlite::Error::QueryReturnedNoRows)) => Err(err),
+            Err(err @ crate::sql::Error::Sql(rusqlite::Error::QueryReturnedNoRows)) => {
+                Err(err.into())
+            }
             Err(err) => {
                 error!(
                     context,
                     "chat: failed to load from db {}: {:?}", chat_id, err
                 );
-                Err(err)
+                Err(err.into())
             }
             Ok(mut chat) => {
                 match chat.id {
@@ -129,7 +131,8 @@ impl Chat {
             &context.sql,
             "UPDATE chats SET param=? WHERE id=?",
             params![self.param.to_string(), self.id as i32],
-        )
+        )?;
+        Ok(())
     }
 
     pub fn get_id(&self) -> u32 {
@@ -637,7 +640,7 @@ pub fn create_or_lookup_by_contact_id(
         context,
         &context.sql,
         format!(
-            "INSERT INTO chats (type, name, param, blocked, grpid) VALUES({}, '{}', '{}', {}, '{}')",
+            "INSERT INTO chats (type, name, param, blocked, grpid, created_timestamp) VALUES({}, '{}', '{}', {}, '{}', {})",
             100,
             chat_name,
             match contact_id {
@@ -650,6 +653,7 @@ pub fn create_or_lookup_by_contact_id(
             },
             create_blocked as u8,
             contact.get_addr(),
+            time(),
         ),
         params![],
     )?;
@@ -680,7 +684,7 @@ pub fn lookup_by_contact_id(context: &Context, contact_id: u32) -> Result<(u32,
         "SELECT c.id, c.blocked FROM chats c INNER JOIN chats_contacts j ON c.id=j.chat_id WHERE c.type=100 AND c.id>9 AND j.contact_id=?;",
         params![contact_id as i32],
         |row| Ok((row.get(0)?, row.get::<_, Option<_>>(1)?.unwrap_or_default())),
-    )
+    ).map_err(Into::into)
 }
 
 pub fn get_by_contact_id(context: &Context, contact_id: u32) -> Result<u32, Error> {
@@ -828,7 +832,8 @@ pub fn unarchive(context: &Context, chat_id: u32) -> Result<(), Error> {
         &context.sql,
         "UPDATE chats SET archived=0 WHERE id=?",
         params![chat_id as i32],
-    )
+    )?;
+    Ok(())
 }
 
 /// Send a message defined by a dc_msg_t object to a chat.
@@ -975,7 +980,8 @@ fn do_set_draft(context: &Context, chat_id: u32, msg: &mut Message) -> Result<()
             msg.param.to_string(),
             1,
         ],
-    )
+    )?;
+    Ok(())
 }
 
 // similar to as dc_set_draft() but does not emit an event
@@ -1388,7 +1394,7 @@ pub fn create_group_chat(
     sql::execute(
         context,
         &context.sql,
-        "INSERT INTO chats (type, name, grpid, param) VALUES(?, ?, ?, \'U=1\');",
+        "INSERT INTO chats (type, name, grpid, param, created_timestamp) VALUES(?, ?, ?, \'U=1\', ?);",
         params![
             if verified != VerifiedStatus::Unverified {
                 Chattype::VerifiedGroup
@@ -1396,7 +1402,8 @@ pub fn create_group_chat(
                 Chattype::Group
             },
             chat_name.as_ref(),
-            grpid
+            grpid,
+            time(),
         ],
     )?;
 
@@ -1486,7 +1493,7 @@ pub(crate) fn add_contact_to_chat_ex(
     let self_addr = context
         .get_config(Config::ConfiguredAddr)
         .unwrap_or_default();
-    if contact.get_addr() == &self_addr {
+    if addr_cmp(contact.get_addr(), &self_addr) {
         // ourself is added using DC_CONTACT_ID_SELF, do not add this address explicitly.
         // if SELF is not in the group, members cannot be added at all.
         warn!(
@@ -1683,10 +1690,13 @@ fn set_group_explicitly_left(context: &Context, grpid: impl AsRef<str>) -> Resul
 }
 
 pub fn is_group_explicitly_left(context: &Context, grpid: impl AsRef<str>) -> Result<bool, Error> {
-    context.sql.exists(
-        "SELECT id FROM leftgrps WHERE grpid=?;",
-        params![grpid.as_ref()],
-    )
+    context
+        .sql
+        .exists(
+            "SELECT id FROM leftgrps WHERE grpid=?;",
+            params![grpid.as_ref()],
+        )
+        .map_err(Into::into)
 }
 
 pub fn set_chat_name(
@@ -1795,8 +1805,8 @@ pub fn set_chat_profile_image(
         ));
     } else {
         let image_blob = BlobObject::from_path(context, Path::new(new_image.as_ref())).or_else(
-            |err| match err.kind() {
-                BlobErrorKind::WrongBlobdir => {
+            |err| match err {
+                BlobError::WrongBlobdir { .. } => {
                     BlobObject::create_and_copy(context, Path::new(new_image.as_ref()))
                 }
                 _ => Err(err),
@@ -1960,8 +1970,7 @@ pub fn add_device_msg(
         label.is_some() || msg.is_some(),
         "device-messages need label, msg or both"
     );
-    let (chat_id, _blocked) =
-        create_or_lookup_by_contact_id(context, DC_CONTACT_ID_DEVICE, Blocked::Not)?;
+    let mut chat_id = 0;
     let mut msg_id = MsgId::new_unset();
 
     if let Some(label) = label {
@@ -1972,7 +1981,10 @@ pub fn add_device_msg(
     }
 
     if let Some(msg) = msg {
+        chat_id = create_or_lookup_by_contact_id(context, DC_CONTACT_ID_DEVICE, Blocked::Not)?.0;
+
         let rfc724_mid = dc_create_outgoing_rfc724_mid(None, "@device");
+        msg.try_calc_and_set_dimensions(context).ok();
         prepare_msg_blob(context, msg)?;
         unarchive(context, chat_id)?;
 
@@ -2251,6 +2263,22 @@ mod tests {
         assert!(was_device_msg_ever_added(&t.ctx, "").is_err());
     }
 
+    #[test]
+    fn test_delete_device_chat() {
+        let t = test_context(Some(Box::new(logging_cb)));
+
+        let mut msg = Message::new(Viewtype::Text);
+        msg.text = Some("message text".to_string());
+        add_device_msg(&t.ctx, Some("some-label"), Some(&mut msg)).ok();
+        let chats = Chatlist::try_load(&t.ctx, 0, None, None).unwrap();
+        assert_eq!(chats.len(), 1);
+
+        // after the device-chat and all messages are deleted, a re-adding should do nothing
+        delete(&t.ctx, chats.get_chat_id(0)).ok();
+        add_device_msg(&t.ctx, Some("some-label"), Some(&mut msg)).ok();
+        assert_eq!(chatlist_len(&t.ctx, 0), 0)
+    }
+
     fn chatlist_len(ctx: &Context, listflags: usize) -> usize {
         Chatlist::try_load(ctx, listflags, None, None)
             .unwrap()

src/chatlist.rs

@@ -6,7 +6,7 @@ use crate::contact::*;
 use crate::context::*;
 use crate::error::Result;
 use crate::lot::Lot;
-use crate::message::{Message, MsgId};
+use crate::message::{Message, MessageState, MsgId};
 use crate::stock::StockMessage;
 
 /// An object representing a single chatlist in memory.
@@ -119,46 +119,42 @@ impl Chatlist {
         let mut ids = if let Some(query_contact_id) = query_contact_id {
             // show chats shared with a given contact
             context.sql.query_map(
-                concat!(
-                    "SELECT c.id, m.id",
-                    " FROM chats c",
-                    " LEFT JOIN msgs m",
-                    "        ON c.id=m.chat_id",
-                    "       AND m.timestamp=(",
-                    "               SELECT MAX(timestamp)",
-                    "                 FROM msgs",
-                    "                WHERE chat_id=c.id",
-                    "                  AND hidden=0)",
-                    " WHERE c.id>9",
-                    "   AND c.blocked=0",
-                    "   AND c.id IN(SELECT chat_id FROM chats_contacts WHERE contact_id=?)",
-                    " GROUP BY c.id",
-                    " ORDER BY IFNULL(m.timestamp,0) DESC, m.id DESC;"
-                ),
-                params![query_contact_id as i32],
+                "SELECT c.id, m.id
+                 FROM chats c
+                 LEFT JOIN msgs m
+                        ON c.id=m.chat_id
+                       AND m.timestamp=(
+                               SELECT MAX(timestamp)
+                                 FROM msgs
+                                WHERE chat_id=c.id
+                                  AND (hidden=0 OR state=?))
+                 WHERE c.id>9
+                   AND c.blocked=0
+                   AND c.id IN(SELECT chat_id FROM chats_contacts WHERE contact_id=?)
+                 GROUP BY c.id
+                 ORDER BY IFNULL(m.timestamp,c.created_timestamp) DESC, m.id DESC;",
+                params![MessageState::OutDraft, query_contact_id as i32],
                 process_row,
                 process_rows,
             )?
         } else if 0 != listflags & DC_GCL_ARCHIVED_ONLY {
             // show archived chats
             context.sql.query_map(
-                concat!(
-                    "SELECT c.id, m.id",
-                    " FROM chats c",
-                    " LEFT JOIN msgs m",
-                    "        ON c.id=m.chat_id",
-                    "       AND m.timestamp=(",
-                    "               SELECT MAX(timestamp)",
-                    "                 FROM msgs",
-                    "                WHERE chat_id=c.id",
-                    "                  AND hidden=0)",
-                    " WHERE c.id>9",
-                    "   AND c.blocked=0",
-                    "   AND c.archived=1",
-                    " GROUP BY c.id",
-                    " ORDER BY IFNULL(m.timestamp,0) DESC, m.id DESC;"
-                ),
-                params![],
+                "SELECT c.id, m.id
+                 FROM chats c
+                 LEFT JOIN msgs m
+                        ON c.id=m.chat_id
+                       AND m.timestamp=(
+                               SELECT MAX(timestamp)
+                                 FROM msgs
+                                WHERE chat_id=c.id
+                                  AND (hidden=0 OR state=?))
+                 WHERE c.id>9
+                   AND c.blocked=0
+                   AND c.archived=1
+                 GROUP BY c.id
+                 ORDER BY IFNULL(m.timestamp,c.created_timestamp) DESC, m.id DESC;",
+                params![MessageState::OutDraft],
                 process_row,
                 process_rows,
             )?
@@ -168,46 +164,42 @@ impl Chatlist {
 
             let str_like_cmd = format!("%{}%", query);
             context.sql.query_map(
-                concat!(
-                    "SELECT c.id, m.id",
-                    " FROM chats c",
-                    " LEFT JOIN msgs m",
-                    "        ON c.id=m.chat_id",
-                    "       AND m.timestamp=(",
-                    "               SELECT MAX(timestamp)",
-                    "                 FROM msgs",
-                    "                WHERE chat_id=c.id",
-                    "                  AND hidden=0)",
-                    " WHERE c.id>9",
-                    "   AND c.blocked=0",
-                    "   AND c.name LIKE ?",
-                    " GROUP BY c.id",
-                    " ORDER BY IFNULL(m.timestamp,0) DESC, m.id DESC;"
-                ),
-                params![str_like_cmd],
+                "SELECT c.id, m.id
+                 FROM chats c
+                 LEFT JOIN msgs m
+                        ON c.id=m.chat_id
+                       AND m.timestamp=(
+                               SELECT MAX(timestamp)
+                                 FROM msgs
+                                WHERE chat_id=c.id
+                                  AND (hidden=0 OR state=?))
+                 WHERE c.id>9
+                   AND c.blocked=0
+                   AND c.name LIKE ?
+                 GROUP BY c.id
+                 ORDER BY IFNULL(m.timestamp,c.created_timestamp) DESC, m.id DESC;",
+                params![MessageState::OutDraft, str_like_cmd],
                 process_row,
                 process_rows,
             )?
         } else {
             //  show normal chatlist
             let mut ids = context.sql.query_map(
-                concat!(
-                    "SELECT c.id, m.id",
-                    " FROM chats c",
-                    " LEFT JOIN msgs m",
-                    "        ON c.id=m.chat_id",
-                    "       AND m.timestamp=(",
-                    "               SELECT MAX(timestamp)",
-                    "                 FROM msgs",
-                    "                WHERE chat_id=c.id",
-                    "                  AND hidden=0)",
-                    " WHERE c.id>9",
-                    "   AND c.blocked=0",
-                    "   AND c.archived=0",
-                    " GROUP BY c.id",
-                    " ORDER BY IFNULL(m.timestamp,0) DESC, m.id DESC;"
-                ),
-                params![],
+                "SELECT c.id, m.id
+                 FROM chats c
+                 LEFT JOIN msgs m
+                        ON c.id=m.chat_id
+                       AND m.timestamp=(
+                               SELECT MAX(timestamp)
+                                 FROM msgs
+                                WHERE chat_id=c.id
+                                  AND (hidden=0 OR state=?))
+                 WHERE c.id>9
+                   AND c.blocked=0
+                   AND c.archived=0
+                 GROUP BY c.id
+                 ORDER BY IFNULL(m.timestamp,c.created_timestamp) DESC, m.id DESC;",
+                params![MessageState::OutDraft],
                 process_row,
                 process_rows,
             )?;
@@ -297,7 +289,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)
             {
@@ -309,16 +301,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
@@ -362,3 +344,44 @@ fn get_last_deaddrop_fresh_msg(context: &Context) -> Option<MsgId> {
         params![],
     )
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::chat;
+    use crate::test_utils::*;
+
+    #[test]
+    fn test_try_load() {
+        let t = dummy_context();
+        let chat_id1 = create_group_chat(&t.ctx, VerifiedStatus::Unverified, "a chat").unwrap();
+        let chat_id2 = create_group_chat(&t.ctx, VerifiedStatus::Unverified, "b chat").unwrap();
+        let chat_id3 = create_group_chat(&t.ctx, VerifiedStatus::Unverified, "c chat").unwrap();
+
+        // check that the chatlist starts with the most recent message
+        let chats = Chatlist::try_load(&t.ctx, 0, None, None).unwrap();
+        assert_eq!(chats.len(), 3);
+        assert_eq!(chats.get_chat_id(0), chat_id3);
+        assert_eq!(chats.get_chat_id(1), chat_id2);
+        assert_eq!(chats.get_chat_id(2), chat_id1);
+
+        // drafts are sorted to the top
+        let mut msg = Message::new(Viewtype::Text);
+        msg.set_text(Some("hello".to_string()));
+        set_draft(&t.ctx, chat_id2, Some(&mut msg));
+        let chats = Chatlist::try_load(&t.ctx, 0, None, None).unwrap();
+        assert_eq!(chats.get_chat_id(0), chat_id2);
+
+        // check chatlist query and archive functionality
+        let chats = Chatlist::try_load(&t.ctx, 0, Some("b"), None).unwrap();
+        assert_eq!(chats.len(), 1);
+
+        let chats = Chatlist::try_load(&t.ctx, DC_GCL_ARCHIVED_ONLY, None, None).unwrap();
+        assert_eq!(chats.len(), 0);
+
+        chat::archive(&t.ctx, chat_id1, true).ok();
+        let chats = Chatlist::try_load(&t.ctx, DC_GCL_ARCHIVED_ONLY, None, None).unwrap();
+        assert_eq!(chats.len(), 1);
+    }
+}

src/config.rs

@@ -7,7 +7,6 @@ use crate::blob::BlobObject;
 use crate::constants::DC_VERSION_STR;
 use crate::context::Context;
 use crate::dc_tools::*;
-use crate::error::Error;
 use crate::job::*;
 use crate::stock::StockMessage;
 
@@ -29,27 +28,38 @@ pub enum Config {
     SendPort,
     SmtpCertificateChecks,
     ServerFlags,
+
     #[strum(props(default = "INBOX"))]
     ImapFolder,
+
     Displayname,
     Selfstatus,
     Selfavatar,
+
     #[strum(props(default = "0"))]
     BccSelf,
+
     #[strum(props(default = "1"))]
     E2eeEnabled,
+
     #[strum(props(default = "1"))]
     MdnsEnabled,
+
     #[strum(props(default = "1"))]
     InboxWatch,
+
     #[strum(props(default = "1"))]
     SentboxWatch,
+
     #[strum(props(default = "1"))]
     MvboxWatch,
+
     #[strum(props(default = "1"))]
     MvboxMove,
+
     #[strum(props(default = "0"))] // also change ShowEmails.default() on changes
     ShowEmails,
+
     SaveMimeHeaders,
     ConfiguredAddr,
     ConfiguredMailServer,
@@ -67,11 +77,13 @@ pub enum Config {
     ConfiguredSendSecurity,
     ConfiguredE2EEEnabled,
     Configured,
-    // Deprecated
+
     #[strum(serialize = "sys.version")]
     SysVersion,
+
     #[strum(serialize = "sys.msgsize_max_recommended")]
     SysMsgsizeMaxRecommended,
+
     #[strum(serialize = "sys.config_keys")]
     SysConfigKeys,
 }
@@ -113,7 +125,7 @@ impl Context {
 
     /// Set the given config key.
     /// If `None` is passed as a value the value is cleared and set to the default if there is one.
-    pub fn set_config(&self, key: Config, value: Option<&str>) -> Result<(), Error> {
+    pub fn set_config(&self, key: Config, value: Option<&str>) -> crate::sql::Result<()> {
         match key {
             Config::Selfavatar if value.is_some() => {
                 let blob = BlobObject::create_from_path(&self, value.unwrap())?;

src/configure/auto_mozilla.rs

@@ -1,17 +1,45 @@
-//! Thunderbird's Autoconfiguration implementation
+//! # Thunderbird's Autoconfiguration implementation
+//!
+//! Documentation: https://developer.mozilla.org/en-US/docs/Mozilla/Thunderbird/Autoconfiguration */
+use failure::Fail;
+
 use quick_xml;
 use quick_xml::events::{BytesEnd, BytesStart, BytesText};
 
 use crate::constants::*;
 use crate::context::Context;
-use crate::error::Error;
 use crate::login_param::LoginParam;
 
-use super::read_autoconf_file;
-/* ******************************************************************************
- * Thunderbird's Autoconfigure
- ******************************************************************************/
-/* documentation: https://developer.mozilla.org/en-US/docs/Mozilla/Thunderbird/Autoconfiguration */
+use super::read_url::read_url;
+
+#[derive(Debug, Fail)]
+pub enum Error {
+    #[fail(display = "Invalid email address: {:?}", _0)]
+    InvalidEmailAddress(String),
+
+    #[fail(display = "XML error at position {}", position)]
+    InvalidXml {
+        position: usize,
+        #[cause]
+        error: quick_xml::Error,
+    },
+
+    #[fail(display = "Bad or incomplete autoconfig")]
+    IncompleteAutoconfig(LoginParam),
+
+    #[fail(display = "Failed to get URL {}", _0)]
+    ReadUrlError(#[cause] super::read_url::Error),
+}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+impl From<super::read_url::Error> for Error {
+    fn from(err: super::read_url::Error) -> Error {
+        Error::ReadUrlError(err)
+    }
+}
+
+#[derive(Debug)]
 struct MozAutoconfigure<'a> {
     pub in_emailaddr: &'a str,
     pub in_emaildomain: &'a str,
@@ -23,13 +51,14 @@ struct MozAutoconfigure<'a> {
     pub tag_config: MozConfigTag,
 }
 
-#[derive(PartialEq)]
+#[derive(Debug, PartialEq)]
 enum MozServer {
     Undefined,
     Imap,
     Smtp,
 }
 
+#[derive(Debug)]
 enum MozConfigTag {
     Undefined,
     Hostname,
@@ -38,15 +67,14 @@ enum MozConfigTag {
     Username,
 }
 
-pub fn moz_parse_xml(in_emailaddr: &str, xml_raw: &str) -> Result<LoginParam, Error> {
+fn parse_xml(in_emailaddr: &str, xml_raw: &str) -> Result<LoginParam> {
     let mut reader = quick_xml::Reader::from_str(xml_raw);
     reader.trim_text(true);
 
     // Split address into local part and domain part.
-    let p = match in_emailaddr.find('@') {
-        Some(i) => i,
-        None => bail!("Email address {} does not contain @", in_emailaddr),
-    };
+    let p = in_emailaddr
+        .find('@')
+        .ok_or(Error::InvalidEmailAddress(in_emailaddr.to_string()))?;
     let (in_emaillocalpart, in_emaildomain) = in_emailaddr.split_at(p);
     let in_emaildomain = &in_emaildomain[1..];
 
@@ -63,22 +91,22 @@ pub fn moz_parse_xml(in_emailaddr: &str, xml_raw: &str) -> Result<LoginParam, Er
 
     let mut buf = Vec::new();
     loop {
-        match reader.read_event(&mut buf) {
-            Ok(quick_xml::events::Event::Start(ref e)) => {
+        let event = reader
+            .read_event(&mut buf)
+            .map_err(|error| Error::InvalidXml {
+                position: reader.buffer_position(),
+                error,
+            })?;
+
+        match event {
+            quick_xml::events::Event::Start(ref e) => {
                 moz_autoconfigure_starttag_cb(e, &mut moz_ac, &reader)
             }
-            Ok(quick_xml::events::Event::End(ref e)) => moz_autoconfigure_endtag_cb(e, &mut moz_ac),
-            Ok(quick_xml::events::Event::Text(ref e)) => {
+            quick_xml::events::Event::End(ref e) => moz_autoconfigure_endtag_cb(e, &mut moz_ac),
+            quick_xml::events::Event::Text(ref e) => {
                 moz_autoconfigure_text_cb(e, &mut moz_ac, &reader)
             }
-            Err(e) => {
-                bail!(
-                    "Configure xml: Error at position {}: {:?}",
-                    reader.buffer_position(),
-                    e
-                );
-            }
-            Ok(quick_xml::events::Event::Eof) => break,
+            quick_xml::events::Event::Eof => break,
             _ => (),
         }
         buf.clear();
@@ -89,27 +117,26 @@ pub fn moz_parse_xml(in_emailaddr: &str, xml_raw: &str) -> Result<LoginParam, Er
         || moz_ac.out.send_server.is_empty()
         || moz_ac.out.send_port == 0
     {
-        let r = moz_ac.out.to_string();
-        bail!("Bad or incomplete autoconfig: {}", r,);
+        Err(Error::IncompleteAutoconfig(moz_ac.out))
+    } else {
+        Ok(moz_ac.out)
     }
-
-    Ok(moz_ac.out)
 }
 
 pub fn moz_autoconfigure(
     context: &Context,
     url: &str,
     param_in: &LoginParam,
-) -> Option<LoginParam> {
-    let xml_raw = read_autoconf_file(context, url)?;
+) -> Result<LoginParam> {
+    let xml_raw = read_url(context, url)?;
 
-    match moz_parse_xml(&param_in.addr, &xml_raw) {
-        Err(err) => {
-            warn!(context, "{}", err);
-            None
-        }
-        Ok(lp) => Some(lp),
-    }
+    parse_xml(&param_in.addr, &xml_raw).map_err(|err| {
+        warn!(
+            context,
+            "Failed to parse Thunderbird autoconfiguration XML: {}", err
+        );
+        err.into()
+    })
 }
 
 fn moz_autoconfigure_text_cb<B: std::io::BufRead>(
@@ -314,7 +341,7 @@ mod tests {
     </loginPageInfo>
   </webMail>
 </clientConfig>";
-        let res = moz_parse_xml("example@outlook.com", xml_raw).expect("XML parsing failed");
+        let res = parse_xml("example@outlook.com", xml_raw).expect("XML parsing failed");
         assert_eq!(res.mail_server, "outlook.office365.com");
         assert_eq!(res.mail_port, 993);
         assert_eq!(res.send_server, "smtp.office365.com");

src/configure/auto_outlook.rs

@@ -1,14 +1,43 @@
+//! Outlook's Autodiscover
+
+use failure::Fail;
+
 use quick_xml;
 use quick_xml::events::BytesEnd;
 
 use crate::constants::*;
 use crate::context::Context;
-use crate::error::Error;
 use crate::login_param::LoginParam;
 
-use super::read_autoconf_file;
+use super::read_url::read_url;
+
+#[derive(Debug, Fail)]
+pub enum Error {
+    #[fail(display = "XML error at position {}", position)]
+    InvalidXml {
+        position: usize,
+        #[cause]
+        error: quick_xml::Error,
+    },
+
+    #[fail(display = "Bad or incomplete autoconfig")]
+    IncompleteAutoconfig(LoginParam),
+
+    #[fail(display = "Failed to get URL {}", _0)]
+    ReadUrlError(#[cause] super::read_url::Error),
+
+    #[fail(display = "Number of redirection is exceeded")]
+    RedirectionError,
+}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+impl From<super::read_url::Error> for Error {
+    fn from(err: super::read_url::Error) -> Error {
+        Error::ReadUrlError(err)
+    }
+}
 
-/// Outlook's Autodiscover
 struct OutlookAutodiscover {
     pub out: LoginParam,
     pub out_imap_set: bool,
@@ -25,7 +54,7 @@ enum ParsingResult {
     RedirectUrl(String),
 }
 
-fn outlk_parse_xml(xml_raw: &str) -> Result<ParsingResult, Error> {
+fn parse_xml(xml_raw: &str) -> Result<ParsingResult> {
     let mut outlk_ad = OutlookAutodiscover {
         out: LoginParam::new(),
         out_imap_set: false,
@@ -45,8 +74,15 @@ fn outlk_parse_xml(xml_raw: &str) -> Result<ParsingResult, Error> {
     let mut current_tag: Option<String> = None;
 
     loop {
-        match reader.read_event(&mut buf) {
-            Ok(quick_xml::events::Event::Start(ref e)) => {
+        let event = reader
+            .read_event(&mut buf)
+            .map_err(|error| Error::InvalidXml {
+                position: reader.buffer_position(),
+                error,
+            })?;
+
+        match event {
+            quick_xml::events::Event::Start(ref e) => {
                 let tag = String::from_utf8_lossy(e.name()).trim().to_lowercase();
 
                 if tag == "protocol" {
@@ -61,11 +97,11 @@ fn outlk_parse_xml(xml_raw: &str) -> Result<ParsingResult, Error> {
                     current_tag = Some(tag);
                 }
             }
-            Ok(quick_xml::events::Event::End(ref e)) => {
+            quick_xml::events::Event::End(ref e) => {
                 outlk_autodiscover_endtag_cb(e, &mut outlk_ad);
                 current_tag = None;
             }
-            Ok(quick_xml::events::Event::Text(ref e)) => {
+            quick_xml::events::Event::Text(ref e) => {
                 let val = e.unescape_and_decode(&reader).unwrap_or_default();
 
                 if let Some(ref tag) = current_tag {
@@ -81,21 +117,14 @@ fn outlk_parse_xml(xml_raw: &str) -> Result<ParsingResult, Error> {
                     };
                 }
             }
-            Err(e) => {
-                bail!(
-                    "Configure xml: Error at position {}: {:?}",
-                    reader.buffer_position(),
-                    e
-                );
-            }
-            Ok(quick_xml::events::Event::Eof) => break,
+            quick_xml::events::Event::Eof => break,
             _ => (),
         }
         buf.clear();
     }
 
     // XML redirect via redirecturl
-    if outlk_ad.config_redirecturl.is_none()
+    let res = if outlk_ad.config_redirecturl.is_none()
         || outlk_ad.config_redirecturl.as_ref().unwrap().is_empty()
     {
         if outlk_ad.out.mail_server.is_empty()
@@ -103,41 +132,34 @@ fn outlk_parse_xml(xml_raw: &str) -> Result<ParsingResult, Error> {
             || outlk_ad.out.send_server.is_empty()
             || outlk_ad.out.send_port == 0
         {
-            let r = outlk_ad.out.to_string();
-            bail!("Bad or incomplete autoconfig: {}", r,);
+            return Err(Error::IncompleteAutoconfig(outlk_ad.out));
         }
-        Ok(ParsingResult::LoginParam(outlk_ad.out))
+        ParsingResult::LoginParam(outlk_ad.out)
     } else {
-        Ok(ParsingResult::RedirectUrl(
-            outlk_ad.config_redirecturl.unwrap(),
-        ))
-    }
+        ParsingResult::RedirectUrl(outlk_ad.config_redirecturl.unwrap())
+    };
+    Ok(res)
 }
 
 pub fn outlk_autodiscover(
     context: &Context,
     url: &str,
     _param_in: &LoginParam,
-) -> Option<LoginParam> {
+) -> Result<LoginParam> {
     let mut url = url.to_string();
-    /* Follow up to 10 xml-redirects (http-redirects are followed in read_autoconf_file() */
+    /* Follow up to 10 xml-redirects (http-redirects are followed in read_url() */
     for _i in 0..10 {
-        if let Some(xml_raw) = read_autoconf_file(context, &url) {
-            match outlk_parse_xml(&xml_raw) {
-                Err(err) => {
-                    warn!(context, "{}", err);
-                    return None;
-                }
-                Ok(res) => match res {
-                    ParsingResult::RedirectUrl(redirect_url) => url = redirect_url,
-                    ParsingResult::LoginParam(login_param) => return Some(login_param),
-                },
-            }
-        } else {
-            return None;
+        let xml_raw = read_url(context, &url)?;
+        let res = parse_xml(&xml_raw);
+        if let Err(err) = &res {
+            warn!(context, "{}", err);
+        }
+        match res? {
+            ParsingResult::RedirectUrl(redirect_url) => url = redirect_url,
+            ParsingResult::LoginParam(login_param) => return Ok(login_param),
         }
     }
-    None
+    Err(Error::RedirectionError)
 }
 
 fn outlk_autodiscover_endtag_cb(event: &BytesEnd, outlk_ad: &mut OutlookAutodiscover) {
@@ -179,7 +201,7 @@ mod tests {
 
     #[test]
     fn test_parse_redirect() {
-        let res = outlk_parse_xml("
+        let res = parse_xml("
 <?xml version=\"1.0\" encoding=\"utf-8\"?>
   <Autodiscover xmlns=\"http://schemas.microsoft.com/exchange/autodiscover/responseschema/2006\">
     <Response xmlns=\"http://schemas.microsoft.com/exchange/autodiscover/outlook/responseschema/2006a\">
@@ -206,7 +228,7 @@ mod tests {
 
     #[test]
     fn test_parse_loginparam() {
-        let res = outlk_parse_xml(
+        let res = parse_xml(
             "\
 <?xml version=\"1.0\" encoding=\"utf-8\"?>
 <Autodiscover xmlns=\"http://schemas.microsoft.com/exchange/autodiscover/responseschema/2006\">

src/configure/mod.rs

@@ -1,5 +1,9 @@
 //! Email accounts autoconfiguration process module
 
+mod auto_mozilla;
+mod auto_outlook;
+mod read_url;
+
 use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
 
 use crate::config::Config;
@@ -12,10 +16,8 @@ use crate::login_param::LoginParam;
 use crate::oauth2::*;
 use crate::param::Params;
 
-mod auto_outlook;
-use auto_outlook::outlk_autodiscover;
-mod auto_mozilla;
 use auto_mozilla::moz_autoconfigure;
+use auto_outlook::outlk_autodiscover;
 
 macro_rules! progress {
     ($context:tt, $progress:expr) => {
@@ -166,7 +168,7 @@ pub fn JobConfigureImap(context: &Context) {
                         "https://autoconfig.{}/mail/config-v1.1.xml?emailaddress={}",
                         param_domain, param_addr_urlencoded
                     );
-                    param_autoconfig = moz_autoconfigure(context, &url, &param);
+                    param_autoconfig = moz_autoconfigure(context, &url, &param).ok();
                 }
                 true
             }
@@ -178,7 +180,7 @@ pub fn JobConfigureImap(context: &Context) {
                         "https://{}/.well-known/autoconfig/mail/config-v1.1.xml?emailaddress={}",
                         param_domain, param_addr_urlencoded
                     );
-                    param_autoconfig = moz_autoconfigure(context, &url, &param);
+                    param_autoconfig = moz_autoconfigure(context, &url, &param).ok();
                 }
                 true
             }
@@ -191,7 +193,7 @@ pub fn JobConfigureImap(context: &Context) {
                         "https://{}{}/autodiscover/autodiscover.xml",
                         "", param_domain
                     );
-                    param_autoconfig = outlk_autodiscover(context, &url, &param);
+                    param_autoconfig = outlk_autodiscover(context, &url, &param).ok();
                 }
                 true
             }
@@ -202,7 +204,7 @@ pub fn JobConfigureImap(context: &Context) {
                         "https://{}{}/autodiscover/autodiscover.xml",
                         "autodiscover.", param_domain
                     );
-                    param_autoconfig = outlk_autodiscover(context, &url, &param);
+                    param_autoconfig = outlk_autodiscover(context, &url, &param).ok();
                 }
                 true
             }
@@ -214,7 +216,7 @@ pub fn JobConfigureImap(context: &Context) {
                         "http://autoconfig.{}/mail/config-v1.1.xml?emailaddress={}",
                         param_domain, param_addr_urlencoded
                     );
-                    param_autoconfig = moz_autoconfigure(context, &url, &param);
+                    param_autoconfig = moz_autoconfigure(context, &url, &param).ok();
                 }
                 true
             }
@@ -226,7 +228,7 @@ pub fn JobConfigureImap(context: &Context) {
                         "http://{}/.well-known/autoconfig/mail/config-v1.1.xml",
                         param_domain
                     );
-                    param_autoconfig = moz_autoconfigure(context, &url, &param);
+                    param_autoconfig = moz_autoconfigure(context, &url, &param).ok();
                 }
                 true
             }
@@ -236,7 +238,7 @@ pub fn JobConfigureImap(context: &Context) {
                 if param_autoconfig.is_none() {
                     /* always SSL for Thunderbird's database */
                     let url = format!("https://autoconfig.thunderbird.net/v1.1/{}", param_domain);
-                    param_autoconfig = moz_autoconfigure(context, &url, &param);
+                    param_autoconfig = moz_autoconfigure(context, &url, &param).ok();
                 }
                 true
             }
@@ -355,13 +357,19 @@ pub fn JobConfigureImap(context: &Context) {
                 progress!(context, 900);
                 let create_mvbox = context.get_config_bool(Config::MvboxWatch)
                     || context.get_config_bool(Config::MvboxMove);
-                context
-                    .inbox_thread
-                    .read()
-                    .unwrap()
-                    .imap
-                    .configure_folders(context, create_mvbox);
-                true
+                let imap = &context.inbox_thread.read().unwrap().imap;
+                if let Err(err) = imap.ensure_configured_folders(context, create_mvbox) {
+                    warn!(context, "configuring folders failed: {:?}", err);
+                    false
+                } else {
+                    let res = imap.select_with_uidvalidity(context, "INBOX");
+                    if let Err(err) = res {
+                        error!(context, "could not read INBOX status: {:?}", err);
+                        false
+                    } else {
+                        true
+                    }
+                }
             }
             17 => {
                 progress!(context, 910);
@@ -383,11 +391,10 @@ pub fn JobConfigureImap(context: &Context) {
                 // (~30 seconds on a Moto G4 play) and might looks as if message sending is always that slow.
                 e2ee::ensure_secret_key_exists(context);
                 success = true;
-                info!(context, "Configure completed.");
+                info!(context, "key generation completed");
                 progress!(context, 940);
                 break; // We are done here
             }
-
             _ => {
                 error!(context, "Internal error: step counter out of bound",);
                 break;
@@ -410,24 +417,6 @@ pub fn JobConfigureImap(context: &Context) {
         context.smtp.clone().lock().unwrap().disconnect();
     }
 
-    /*
-    if !success {
-        // disconnect if configure did not succeed
-        if imap_connected_here {
-            // context.inbox.read().unwrap().disconnect(context);
-        }
-        if smtp_connected_here {
-            // context.smtp.clone().lock().unwrap().disconnect();
-        }
-    } else {
-        assert!(imap_connected_here && smtp_connected_here);
-        info!(
-            context,
-            0, "Keeping IMAP/SMTP connections open after successful configuration"
-        );
-    }
-    */
-
     // 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.
@@ -575,27 +564,6 @@ fn try_smtp_one_param(context: &Context, param: &LoginParam) -> Option<bool> {
     }
 }
 
-/*******************************************************************************
- * Configure a Context
- ******************************************************************************/
-
-pub fn read_autoconf_file(context: &Context, url: &str) -> Option<String> {
-    info!(context, "Testing {} ...", url);
-
-    match reqwest::Client::new()
-        .get(url)
-        .send()
-        .and_then(|mut res| res.text())
-    {
-        Ok(res) => Some(res),
-        Err(_err) => {
-            info!(context, "Can\'t read file.",);
-
-            None
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
 

src/configure/read_url.rs

@@ -0,0 +1,27 @@
+use crate::context::Context;
+use failure::Fail;
+
+#[derive(Debug, Fail)]
+pub enum Error {
+    #[fail(display = "URL request error")]
+    GetError(#[cause] reqwest::Error),
+}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+pub fn read_url(context: &Context, url: &str) -> Result<String> {
+    info!(context, "Requesting URL {}", url);
+
+    match reqwest::Client::new()
+        .get(url)
+        .send()
+        .and_then(|mut res| res.text())
+    {
+        Ok(res) => Ok(res),
+        Err(err) => {
+            info!(context, "Can\'t read URL {}", url);
+
+            Err(Error::GetError(err))
+        }
+    }
+}

src/contact.rs

@@ -141,7 +141,7 @@ pub enum VerifiedStatus {
 }
 
 impl Contact {
-    pub fn load_from_db(context: &Context, contact_id: u32) -> Result<Self> {
+    pub fn load_from_db(context: &Context, contact_id: u32) -> crate::sql::Result<Self> {
         if contact_id == DC_CONTACT_ID_SELF {
             let contact = Contact {
                 id: contact_id,
@@ -272,7 +272,7 @@ impl Contact {
             .get_config(Config::ConfiguredAddr)
             .unwrap_or_default();
 
-        if addr_normalized == addr_self {
+        if addr_cmp(addr_normalized, addr_self) {
             return DC_CONTACT_ID_SELF;
         }
 
@@ -309,7 +309,7 @@ impl Contact {
             .get_config(Config::ConfiguredAddr)
             .unwrap_or_default();
 
-        if addr == addr_self {
+        if addr_cmp(addr, addr_self) {
             return Ok((DC_CONTACT_ID_SELF, sth_modified));
         }
 
@@ -617,18 +617,18 @@ impl Contact {
                     .peek_key(PeerstateVerifiedStatus::Unverified)
                     .map(|k| k.formatted_fingerprint())
                     .unwrap_or_default();
-                if peerstate.addr.is_some() && &loginparam.addr < peerstate.addr.as_ref().unwrap() {
+                if loginparam.addr < peerstate.addr {
                     cat_fingerprint(&mut ret, &loginparam.addr, &fingerprint_self, "");
                     cat_fingerprint(
                         &mut ret,
-                        peerstate.addr.as_ref().unwrap(),
+                        peerstate.addr.clone(),
                         &fingerprint_other_verified,
                         &fingerprint_other_unverified,
                     );
                 } else {
                     cat_fingerprint(
                         &mut ret,
-                        peerstate.addr.as_ref().unwrap(),
+                        peerstate.addr.clone(),
                         &fingerprint_other_verified,
                         &fingerprint_other_unverified,
                     );
@@ -691,7 +691,7 @@ impl Contact {
                 }
                 Err(err) => {
                     error!(context, "delete_contact {} failed ({})", contact_id, err);
-                    return Err(err);
+                    return Err(err.into());
                 }
             }
         }
@@ -709,7 +709,7 @@ impl Contact {
     /// like "Me" in the selected language and the email address
     /// defined by dc_set_config().
     pub fn get_by_id(context: &Context, contact_id: u32) -> Result<Contact> {
-        Contact::load_from_db(context, contact_id)
+        Ok(Contact::load_from_db(context, contact_id)?)
     }
 
     /// Get the ID of the contact.
@@ -1026,17 +1026,16 @@ fn cat_fingerprint(
 }
 
 pub fn addr_cmp(addr1: impl AsRef<str>, addr2: impl AsRef<str>) -> bool {
-    let norm1 = addr_normalize(addr1.as_ref());
-    let norm2 = addr_normalize(addr2.as_ref());
+    let norm1 = addr_normalize(addr1.as_ref()).to_lowercase();
+    let norm2 = addr_normalize(addr2.as_ref()).to_lowercase();
 
     norm1 == norm2
 }
 
 pub fn addr_equals_self(context: &Context, addr: impl AsRef<str>) -> bool {
     if !addr.as_ref().is_empty() {
-        let normalized_addr = addr_normalize(addr.as_ref());
         if let Some(self_addr) = context.get_config(Config::ConfiguredAddr) {
-            return normalized_addr == self_addr;
+            return addr_cmp(addr, self_addr);
         }
     }
     false
@@ -1088,6 +1087,10 @@ mod tests {
     fn test_normalize_addr() {
         assert_eq!(addr_normalize("mailto:john@doe.com"), "john@doe.com");
         assert_eq!(addr_normalize("  hello@world.com   "), "hello@world.com");
+
+        // normalisation preserves case to allow user-defined spelling.
+        // however, case is ignored on addr_cmp()
+        assert_ne!(addr_normalize("John@Doe.com"), "john@doe.com");
     }
 
     #[test]
@@ -1209,4 +1212,11 @@ mod tests {
         assert_eq!(contact.get_addr(), ""); // we're not configured
         assert!(!contact.is_blocked());
     }
+
+    #[test]
+    fn test_addr_cmp() {
+        assert!(addr_cmp("AA@AA.ORG", "aa@aa.ORG"));
+        assert!(addr_cmp(" aa@aa.ORG ", "AA@AA.ORG"));
+        assert!(addr_cmp(" mailto:AA@AA.ORG", "Aa@Aa.orG"));
+    }
 }

src/context.rs

@@ -15,12 +15,11 @@ use crate::imap::*;
 use crate::job::*;
 use crate::job_thread::JobThread;
 use crate::key::*;
-use crate::log;
 use crate::login_param::LoginParam;
 use crate::lot::Lot;
 use crate::message::{self, Message, MsgId};
 use crate::param::Params;
-use crate::smtp::*;
+use crate::smtp::Smtp;
 use crate::sql::Sql;
 
 /// Callback function type for [Context]
@@ -63,7 +62,6 @@ pub struct Context {
     /// Mutex to avoid generating the key for the user more than once.
     pub generating_key_mutex: Mutex<()>,
     pub translated_stockstrings: RwLock<HashMap<usize, String>>,
-    pub logger: RwLock<log::Logger>,
 }
 
 #[derive(Debug, PartialEq, Eq)]
@@ -88,7 +86,7 @@ pub fn get_info() -> HashMap<&'static str, String> {
     );
     res.insert(
         "arch",
-        (::std::mem::size_of::<*mut libc::c_void>())
+        (std::mem::size_of::<*mut libc::c_void>())
             .wrapping_mul(8)
             .to_string(),
     );
@@ -96,92 +94,30 @@ pub fn get_info() -> HashMap<&'static str, String> {
     res
 }
 
-/// Builder for [Context].
-///
-/// # Example
-///
-/// ```
-/// use deltachat::context::ContextBuilder;
-/// let dir = tempfile::tempdir().unwrap();
-/// let dbfile = dir.path().join("my-context.db");
-/// let ctx = ContextBuilder::new(Box::new(|_, _| 0), "AppName".into(), dbfile)
-///     .blobdir(dir.path().join("my-context-blobs"))
-///     .logdir(dir.path().join("my-context-logs"))
-///     .create()
-///     .unwrap();
-/// assert_eq!(ctx.get_blobdir(), dir.path().join("my-context-blobs"));
-/// ```
-#[derive(DebugStub)]
-pub struct ContextBuilder {
-    #[debug_stub = "Callback"]
-    cb: Box<ContextCallback>,
-    os_name: String,
-    dbfile: PathBuf,
-    blobdir: PathBuf,
-    logdir: PathBuf,
-}
-
-impl ContextBuilder {
-    pub fn new(cb: Box<ContextCallback>, os_name: String, dbfile: PathBuf) -> Self {
-        let db_fname = OsString::from(dbfile.file_name().unwrap_or(&OsString::from("dc-context")));
-        let mut blob_fname = db_fname.clone();
-        blob_fname.push("-blobs");
-        let mut log_fname = db_fname.clone();
-        log_fname.push("-logs");
-        ContextBuilder {
-            cb,
-            os_name,
-            blobdir: dbfile.with_file_name(blob_fname),
-            logdir: dbfile.with_file_name(log_fname),
-            dbfile,
-        }
-    }
-
-    pub fn blobdir(mut self, path: PathBuf) -> Self {
-        self.blobdir = path;
-        self
-    }
-
-    pub fn logdir(mut self, path: PathBuf) -> Self {
-        self.logdir = path;
-        self
-    }
-
-    pub fn create(self) -> Result<Context> {
-        if !self.blobdir.exists() {
-            std::fs::create_dir_all(&self.blobdir)?;
-        }
-        if !self.logdir.exists() {
-            std::fs::create_dir_all(&self.logdir)?;
-        }
-        Context::new(
-            self.cb,
-            self.os_name,
-            self.dbfile,
-            self.blobdir,
-            self.logdir,
-        )
-    }
-}
-
 impl Context {
-    fn new(
+    /// Creates new context.
+    pub fn new(cb: Box<ContextCallback>, os_name: String, dbfile: PathBuf) -> Result<Context> {
+        let mut blob_fname = OsString::new();
+        blob_fname.push(dbfile.file_name().unwrap_or_default());
+        blob_fname.push("-blobs");
+        let blobdir = dbfile.with_file_name(blob_fname);
+        if !blobdir.exists() {
+            std::fs::create_dir_all(&blobdir)?;
+        }
+        Context::with_blobdir(cb, os_name, dbfile, blobdir)
+    }
+
+    pub fn with_blobdir(
         cb: Box<ContextCallback>,
         os_name: String,
         dbfile: PathBuf,
         blobdir: PathBuf,
-        logdir: PathBuf,
     ) -> Result<Context> {
         ensure!(
             blobdir.is_dir(),
             "Blobdir does not exist: {}",
             blobdir.display()
         );
-        ensure!(
-            logdir.is_dir(),
-            "Logdir does not exist: {}",
-            logdir.display()
-        );
         let ctx = Context {
             blobdir,
             dbfile,
@@ -214,7 +150,6 @@ impl Context {
             perform_inbox_jobs_needed: Arc::new(RwLock::new(false)),
             generating_key_mutex: Mutex::new(()),
             translated_stockstrings: RwLock::new(HashMap::new()),
-            logger: RwLock::new(log::Logger::new(logdir)?),
         };
 
         ensure!(
@@ -591,7 +526,7 @@ mod tests {
         let tmp = tempfile::tempdir().unwrap();
         let dbfile = tmp.path().join("db.sqlite");
         std::fs::write(&dbfile, b"123").unwrap();
-        let res = ContextBuilder::new(Box::new(|_, _| 0), "FakeOs".into(), dbfile).create();
+        let res = Context::new(Box::new(|_, _| 0), "FakeOs".into(), dbfile);
         assert!(res.is_err());
     }
 
@@ -606,9 +541,7 @@ mod tests {
     fn test_blobdir_exists() {
         let tmp = tempfile::tempdir().unwrap();
         let dbfile = tmp.path().join("db.sqlite");
-        ContextBuilder::new(Box::new(|_, _| 0), "FakeOS".into(), dbfile)
-            .create()
-            .unwrap();
+        Context::new(Box::new(|_, _| 0), "FakeOS".into(), dbfile).unwrap();
         let blobdir = tmp.path().join("db.sqlite-blobs");
         assert!(blobdir.is_dir());
     }
@@ -619,7 +552,7 @@ mod tests {
         let dbfile = tmp.path().join("db.sqlite");
         let blobdir = tmp.path().join("db.sqlite-blobs");
         std::fs::write(&blobdir, b"123").unwrap();
-        let res = ContextBuilder::new(Box::new(|_, _| 0), "FakeOS".into(), dbfile).create();
+        let res = Context::new(Box::new(|_, _| 0), "FakeOS".into(), dbfile);
         assert!(res.is_err());
     }
 
@@ -629,9 +562,7 @@ mod tests {
         let subdir = tmp.path().join("subdir");
         let dbfile = subdir.join("db.sqlite");
         let dbfile2 = dbfile.clone();
-        ContextBuilder::new(Box::new(|_, _| 0), "FakeOS".into(), dbfile)
-            .create()
-            .unwrap();
+        Context::new(Box::new(|_, _| 0), "FakeOS".into(), dbfile).unwrap();
         assert!(subdir.is_dir());
         assert!(dbfile2.is_file());
     }
@@ -641,9 +572,7 @@ mod tests {
         let tmp = tempfile::tempdir().unwrap();
         let dbfile = tmp.path().join("db.sqlite");
         let blobdir = PathBuf::new();
-        let res = ContextBuilder::new(Box::new(|_, _| 0), "FakeOS".into(), dbfile)
-            .blobdir(blobdir)
-            .create();
+        let res = Context::with_blobdir(Box::new(|_, _| 0), "FakeOS".into(), dbfile, blobdir);
         assert!(res.is_err());
     }
 
@@ -652,36 +581,10 @@ mod tests {
         let tmp = tempfile::tempdir().unwrap();
         let dbfile = tmp.path().join("db.sqlite");
         let blobdir = tmp.path().join("blobs");
-        ContextBuilder::new(Box::new(|_, _| 0), "FakeOS".into(), dbfile)
-            .blobdir(blobdir.clone())
-            .create()
-            .unwrap();
-        assert!(blobdir.is_dir());
-    }
-
-    #[test]
-    fn test_with_empty_logdir() {
-        let tmp = tempfile::tempdir().unwrap();
-        let dbfile = tmp.path().join("db.sqlite");
-        let logdir = PathBuf::new();
-        let res = ContextBuilder::new(Box::new(|_, _| 0), "FakeOS".into(), dbfile)
-            .logdir(logdir)
-            .create();
+        let res = Context::with_blobdir(Box::new(|_, _| 0), "FakeOS".into(), dbfile, blobdir);
         assert!(res.is_err());
     }
 
-    #[test]
-    fn test_with_logdir_not_exists() {
-        let tmp = tempfile::tempdir().unwrap();
-        let dbfile = tmp.path().join("db.sqlite");
-        let logdir = tmp.path().join("logs");
-        ContextBuilder::new(Box::new(|_, _| 0), "FakeOS".into(), dbfile)
-            .logdir(logdir.clone())
-            .create()
-            .unwrap();
-        assert!(logdir.is_dir());
-    }
-
     #[test]
     fn no_crashes_on_context_deref() {
         let t = dummy_context();

src/dc_simplify.rs

@@ -1,4 +1,4 @@
-use crate::dc_dehtml::*;
+use crate::dehtml::*;
 
 #[derive(Copy, Clone)]
 pub struct Simplify {
@@ -34,7 +34,7 @@ impl Simplify {
     /// The data returned from simplify() must be free()'d when no longer used.
     pub fn simplify(&mut self, input: &str, is_html: bool, is_msgrmsg: bool) -> String {
         let mut out = if is_html {
-            dc_dehtml(input)
+            dehtml(input)
         } else {
             input.to_string()
         };

src/dc_strencode.rs

@@ -1,30 +1,17 @@
 use itertools::Itertools;
-use std::borrow::Cow;
-use std::ffi::CString;
-use std::ptr;
 
-use charset::Charset;
-use libc::free;
-use mmime::mailmime::decode::mailmime_encoded_phrase_parse;
-use mmime::other::*;
-use percent_encoding::{percent_decode, utf8_percent_encode, AsciiSet, CONTROLS};
-
-use crate::dc_tools::*;
-
-/**
- * Encode non-ascii-strings as `=?UTF-8?Q?Bj=c3=b6rn_Petersen?=`.
- * Belongs to RFC 2047: https://tools.ietf.org/html/rfc2047
- *
- * We do not fold at position 72; this would result in empty words as `=?utf-8?Q??=` which are correct,
- * but cannot be displayed by some mail programs (eg. Android Stock Mail).
- * however, this is not needed, as long as _one_ word is not longer than 72 characters.
- * _if_ it is, the display may get weird.  This affects the subject only.
- * the best solution wor all this would be if libetpan encodes the line as only libetpan knowns when a header line is full.
- *
- * @param to_encode Null-terminated UTF-8-string to encode.
- * @return Returns the encoded string which must be free()'d when no longed needed.
- *     On errors, NULL is returned.
- */
+/// Encode non-ascii-strings as `=?UTF-8?Q?Bj=c3=b6rn_Petersen?=`.
+/// Belongs to RFC 2047: https://tools.ietf.org/html/rfc2047
+///
+/// We do not fold at position 72; this would result in empty words as `=?utf-8?Q??=` which are correct,
+/// but cannot be displayed by some mail programs (eg. Android Stock Mail).
+/// however, this is not needed, as long as _one_ word is not longer than 72 characters.
+/// _if_ it is, the display may get weird.  This affects the subject only.
+/// the best solution wor all this would be if libetpan encodes the line as only libetpan knowns when a header line is full.
+///
+/// @param to_encode Null-terminated UTF-8-string to encode.
+/// @return Returns the encoded string which must be free()'d when no longed needed.
+///     On errors, NULL is returned.
 pub fn dc_encode_header_words(input: impl AsRef<str>) -> String {
     let mut result = String::default();
     for (_, group) in &input.as_ref().chars().group_by(|c| c.is_whitespace()) {
@@ -68,31 +55,6 @@ fn quote_word(word: &[u8]) -> String {
  * Encode/decode header words, RFC 2047
  ******************************************************************************/
 
-pub(crate) fn dc_decode_header_words(input: &str) -> String {
-    static FROM_ENCODING: &[u8] = b"iso-8859-1\x00";
-    static TO_ENCODING: &[u8] = b"utf-8\x00";
-    let mut out = ptr::null_mut();
-    let mut cur_token = 0;
-    let input_c = CString::yolo(input);
-    unsafe {
-        let r = mailmime_encoded_phrase_parse(
-            FROM_ENCODING.as_ptr().cast(),
-            input_c.as_ptr(),
-            input.len(),
-            &mut cur_token,
-            TO_ENCODING.as_ptr().cast(),
-            &mut out,
-        );
-        if r as u32 != MAILIMF_NO_ERROR || out.is_null() {
-            input.to_string()
-        } else {
-            let res = to_string_lossy(out);
-            free(out.cast());
-            res
-        }
-    }
-}
-
 pub fn dc_needs_ext_header(to_check: impl AsRef<str>) -> bool {
     let to_check = to_check.as_ref();
 
@@ -110,142 +72,3 @@ pub fn dc_needs_ext_header(to_check: impl AsRef<str>) -> bool {
             || c == '%')
     })
 }
-
-const EXT_ASCII_ST: &AsciiSet = &CONTROLS
-    .add(b' ')
-    .add(b'-')
-    .add(b'_')
-    .add(b'.')
-    .add(b'~')
-    .add(b'%');
-
-/// Encode an UTF-8 string to the extended header format.
-pub fn dc_encode_ext_header(to_encode: impl AsRef<str>) -> String {
-    let encoded = utf8_percent_encode(to_encode.as_ref(), &EXT_ASCII_ST);
-    format!("utf-8''{}", encoded)
-}
-
-/// Decode an extended-header-format strings to UTF-8.
-pub fn dc_decode_ext_header(to_decode: &[u8]) -> Cow<str> {
-    if let Some(index) = bytes!(b'\'').find(to_decode) {
-        let (charset, rest) = to_decode.split_at(index);
-        if !charset.is_empty() {
-            // skip language
-            if let Some(index2) = bytes!(b'\'').find(&rest[1..]) {
-                let decoded = percent_decode(&rest[index2 + 2..]);
-
-                if charset != b"utf-8" && charset != b"UTF-8" {
-                    if let Some(encoding) = Charset::for_label(charset) {
-                        let bytes = decoded.collect::<Vec<u8>>();
-                        let (res, _, _) = encoding.decode(&bytes);
-                        return Cow::Owned(res.into_owned());
-                    } else {
-                        return decoded.decode_utf8_lossy();
-                    }
-                } else {
-                    return decoded.decode_utf8_lossy();
-                }
-            }
-        }
-    }
-
-    String::from_utf8_lossy(to_decode)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_dc_decode_header_words() {
-        assert_eq!(
-            dc_decode_header_words("=?utf-8?B?dGVzdMOkw7bDvC50eHQ=?="),
-            std::string::String::from_utf8(b"test\xc3\xa4\xc3\xb6\xc3\xbc.txt".to_vec()).unwrap(),
-        );
-
-        assert_eq!(dc_decode_header_words("just ascii test"), "just ascii test");
-
-        assert_eq!(dc_encode_header_words("abcdef"), "abcdef");
-
-        let r = dc_encode_header_words(
-            std::string::String::from_utf8(b"test\xc3\xa4\xc3\xb6\xc3\xbc.txt".to_vec()).unwrap(),
-        );
-        assert!(r.starts_with("=?utf-8"));
-
-        assert_eq!(
-            dc_decode_header_words(&r),
-            std::string::String::from_utf8(b"test\xc3\xa4\xc3\xb6\xc3\xbc.txt".to_vec()).unwrap(),
-        );
-
-        assert_eq!(
-                dc_decode_header_words("=?ISO-8859-1?Q?attachment=3B=0D=0A_filename=3D?= =?ISO-8859-1?Q?=22test=E4=F6=FC=2Etxt=22=3B=0D=0A_size=3D39?="),
-                std::string::String::from_utf8(b"attachment;\r\n filename=\"test\xc3\xa4\xc3\xb6\xc3\xbc.txt\";\r\n size=39".to_vec()).unwrap(),
-            );
-    }
-
-    #[test]
-    fn test_dc_encode_ext_header() {
-        let buf1 = dc_encode_ext_header("Björn Petersen");
-        assert_eq!(&buf1, "utf-8\'\'Bj%C3%B6rn%20Petersen");
-        let buf2 = dc_decode_ext_header(buf1.as_bytes());
-        assert_eq!(&buf2, "Björn Petersen",);
-
-        let buf1 = dc_decode_ext_header(b"iso-8859-1\'en\'%A3%20rates");
-        assert_eq!(buf1, "£ rates",);
-
-        let buf1 = dc_decode_ext_header(b"wrong\'format");
-        assert_eq!(buf1, "wrong\'format",);
-
-        let buf1 = dc_decode_ext_header(b"\'\'");
-        assert_eq!(buf1, "\'\'");
-
-        let buf1 = dc_decode_ext_header(b"x\'\'");
-        assert_eq!(buf1, "");
-
-        let buf1 = dc_decode_ext_header(b"\'");
-        assert_eq!(buf1, "\'");
-
-        let buf1 = dc_decode_ext_header(b"");
-        assert_eq!(buf1, "");
-
-        // regressions
-        assert_eq!(
-            dc_decode_ext_header(dc_encode_ext_header("%0A").as_bytes()),
-            "%0A"
-        );
-    }
-
-    #[test]
-    fn test_dc_needs_ext_header() {
-        assert_eq!(dc_needs_ext_header("Björn"), true);
-        assert_eq!(dc_needs_ext_header("Bjoern"), false);
-        assert_eq!(dc_needs_ext_header(""), false);
-        assert_eq!(dc_needs_ext_header(" "), true);
-        assert_eq!(dc_needs_ext_header("a b"), true);
-    }
-
-    use proptest::prelude::*;
-
-    proptest! {
-        #[test]
-        fn test_ext_header_roundtrip(buf: String) {
-            let encoded = dc_encode_ext_header(&buf);
-            let decoded = dc_decode_ext_header(encoded.as_bytes());
-            assert_eq!(buf, decoded);
-        }
-
-        #[test]
-        fn test_ext_header_decode_anything(buf: Vec<u8>) {
-            // make sure this never panics
-            let _decoded = dc_decode_ext_header(&buf);
-        }
-
-        #[test]
-        fn test_dc_header_roundtrip(input: String) {
-            let encoded = dc_encode_header_words(&input);
-            let decoded = dc_decode_header_words(&encoded);
-
-            assert_eq!(input, decoded);
-        }
-    }
-}

src/dc_tools.rs

@@ -3,54 +3,22 @@
 
 use core::cmp::{max, min};
 use std::borrow::Cow;
-use std::ffi::{CStr, CString};
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::time::SystemTime;
-use std::{fmt, fs, ptr};
+use std::{fmt, fs};
 
 use chrono::{Local, TimeZone};
-use libc::{memcpy, strlen};
-use mmime::clist::*;
-use mmime::mailimf::types::*;
 use rand::{thread_rng, Rng};
 
 use crate::context::Context;
 use crate::error::Error;
 use crate::events::Event;
 
-pub(crate) fn dc_exactly_one_bit_set(v: libc::c_int) -> bool {
+pub(crate) fn dc_exactly_one_bit_set(v: i32) -> bool {
     0 != v && 0 == v & (v - 1)
 }
 
-/// Duplicates a string
-///
-/// returns an empty string if NULL is given, never returns NULL (exits on errors)
-///
-/// # Examples
-///
-/// ```
-/// use deltachat::dc_tools::{dc_strdup, to_string_lossy};
-/// unsafe {
-///     let str_a = b"foobar\x00" as *const u8 as *const libc::c_char;
-///     let str_a_copy = dc_strdup(str_a);
-///     assert_eq!(to_string_lossy(str_a_copy), "foobar");
-///     assert_ne!(str_a, str_a_copy);
-/// }
-/// ```
-pub unsafe fn dc_strdup(s: *const libc::c_char) -> *mut libc::c_char {
-    let ret: *mut libc::c_char;
-    if !s.is_null() {
-        ret = strdup(s);
-        assert!(!ret.is_null());
-    } else {
-        ret = libc::calloc(1, 1) as *mut libc::c_char;
-        assert!(!ret.is_null());
-    }
-
-    ret
-}
-
 /// Shortens a string to a specified length and adds "..." or "[...]" to the end of
 /// the shortened string.
 pub(crate) fn dc_truncate(buf: &str, approx_chars: usize, do_unwrap: bool) -> Cow<str> {
@@ -74,36 +42,12 @@ pub(crate) fn dc_truncate(buf: &str, approx_chars: usize, do_unwrap: bool) -> Co
     }
 }
 
-pub(crate) fn dc_str_from_clist(list: *const clist, delimiter: &str) -> String {
-    let mut res = String::new();
-
-    if !list.is_null() {
-        for rfc724_mid in unsafe { (*list).into_iter() } {
-            if !res.is_empty() {
-                res += delimiter;
-            }
-            res += &to_string_lossy(rfc724_mid as *const libc::c_char);
-        }
-    }
-    res
-}
-
-pub(crate) fn dc_str_to_clist(str: &str, delimiter: &str) -> *mut clist {
-    unsafe {
-        let list: *mut clist = clist_new();
-        for cur in str.split(&delimiter) {
-            clist_insert_after(list, (*list).last, cur.strdup().cast());
-        }
-        list
-    }
-}
-
-/* the colors must fulfill some criterions as:
-- contrast to black and to white
-- work as a text-color
-- being noticeable on a typical map
-- harmonize together while being different enough
-(therefore, we cannot just use random rgb colors :) */
+/// the colors must fulfill some criterions as:
+/// - contrast to black and to white
+/// - work as a text-color
+/// - being noticeable on a typical map
+/// - harmonize together while being different enough
+/// (therefore, we cannot just use random rgb colors :)
 const COLORS: [u32; 16] = [
     0xe56555, 0xf28c48, 0x8e85ee, 0x76c84d, 0x5bb6cc, 0x549cdd, 0xd25c99, 0xb37800, 0xf23030,
     0x39b249, 0xbb243b, 0x964078, 0x66874f, 0x308ab9, 0x127ed0, 0xbe450c,
@@ -122,33 +66,6 @@ pub(crate) fn dc_str_to_color(s: impl AsRef<str>) -> u32 {
     COLORS[color_index]
 }
 
-/* date/time tools */
-/* the result is UTC or DC_INVALID_TIMESTAMP */
-pub(crate) fn dc_timestamp_from_date(date_time: *mut mailimf_date_time) -> i64 {
-    assert!(!date_time.is_null());
-    let dt = unsafe { *date_time };
-
-    let sec = dt.dt_sec;
-    let min = dt.dt_min;
-    let hour = dt.dt_hour;
-    let day = dt.dt_day;
-    let month = dt.dt_month;
-    let year = dt.dt_year;
-
-    let ts = chrono::NaiveDateTime::new(
-        chrono::NaiveDate::from_ymd(year, month as u32, day as u32),
-        chrono::NaiveTime::from_hms(hour as u32, min as u32, sec as u32),
-    );
-
-    let (zone_hour, zone_min) = if dt.dt_zone >= 0 {
-        (dt.dt_zone / 100, dt.dt_zone % 100)
-    } else {
-        (-(-dt.dt_zone / 100), -(-dt.dt_zone % 100))
-    };
-
-    ts.timestamp() - (zone_hour * 3600 + zone_min * 60) as i64
-}
-
 /* ******************************************************************************
  * date/time tools
  ******************************************************************************/
@@ -318,22 +235,6 @@ pub(crate) fn dc_extract_grpid_from_rfc724_mid(mid: &str) -> Option<&str> {
     None
 }
 
-pub(crate) fn dc_extract_grpid_from_rfc724_mid_list(list: *const clist) -> *mut libc::c_char {
-    if !list.is_null() {
-        unsafe {
-            for cur in (*list).into_iter() {
-                let mid = to_string_lossy(cur as *const libc::c_char);
-
-                if let Some(grpid) = dc_extract_grpid_from_rfc724_mid(&mid) {
-                    return grpid.strdup();
-                }
-            }
-        }
-    }
-
-    ptr::null_mut()
-}
-
 pub(crate) fn dc_ensure_no_slash_safe(path: &str) -> &str {
     if path.ends_with('/') || path.ends_with('\\') {
         return &path[..path.len() - 1];
@@ -523,9 +424,13 @@ pub(crate) fn dc_create_folder(context: &Context, path: impl AsRef<std::path::Pa
 }
 
 /// Write a the given content to provied file path.
-pub(crate) fn dc_write_file(context: &Context, path: impl AsRef<Path>, buf: &[u8]) -> bool {
+pub(crate) fn dc_write_file(
+    context: &Context,
+    path: impl AsRef<Path>,
+    buf: &[u8],
+) -> Result<(), std::io::Error> {
     let path_abs = dc_get_abs_path(context, &path);
-    if let Err(err) = fs::write(&path_abs, buf) {
+    fs::write(&path_abs, buf).map_err(|err| {
         warn!(
             context,
             "Cannot write {} bytes to \"{}\": {}",
@@ -533,10 +438,8 @@ pub(crate) fn dc_write_file(context: &Context, path: impl AsRef<Path>, buf: &[u8
             path.as_ref().display(),
             err
         );
-        false
-    } else {
-        true
-    }
+        err
+    })
 }
 
 pub fn dc_read_file<P: AsRef<std::path::Path>>(
@@ -599,212 +502,6 @@ pub(crate) fn dc_get_next_backup_path(
     bail!("could not create backup file, disk full?");
 }
 
-/// Error type for the [OsStrExt] trait
-#[derive(Debug, Fail, PartialEq)]
-pub enum CStringError {
-    /// The string contains an interior null byte
-    #[fail(display = "String contains an interior null byte")]
-    InteriorNullByte,
-    /// The string is not valid Unicode
-    #[fail(display = "String is not valid unicode")]
-    NotUnicode,
-}
-
-/// Extra convenience methods on [std::ffi::OsStr] to work with `*libc::c_char`.
-///
-/// The primary function of this trait is to more easily convert
-/// [OsStr], [OsString] or [Path] into pointers to C strings.  This always
-/// allocates a new string since it is very common for the source
-/// string not to have the required terminal null byte.
-///
-/// It is implemented for `AsRef<std::ffi::OsStr>>` trait, which
-/// allows any type which implements this trait to transparently use
-/// this.  This is how the conversion for [Path] works.
-///
-/// [OsStr]: std::ffi::OsStr
-/// [OsString]: std::ffi::OsString
-/// [Path]: std::path::Path
-///
-/// # Example
-///
-/// ```
-/// use deltachat::dc_tools::{dc_strdup, OsStrExt};
-/// let path = std::path::Path::new("/some/path");
-/// let path_c = path.to_c_string().unwrap();
-/// unsafe {
-///     let mut c_ptr: *mut libc::c_char = dc_strdup(path_c.as_ptr());
-/// }
-/// ```
-pub trait OsStrExt {
-    /// Convert a  [std::ffi::OsStr] to an [std::ffi::CString]
-    ///
-    /// This is useful to convert e.g. a [std::path::Path] to
-    /// [*libc::c_char] by using
-    /// [Path::as_os_str()](std::path::Path::as_os_str) and
-    /// [CStr::as_ptr()](std::ffi::CStr::as_ptr).
-    ///
-    /// This returns [CString] and not [&CStr] because not all [OsStr]
-    /// slices end with a null byte, particularly those coming from
-    /// [Path] do not have a null byte and having to handle this as
-    /// the caller would defeat the point of this function.
-    ///
-    /// On Windows this requires that the [OsStr] contains valid
-    /// unicode, which should normally be the case for a [Path].
-    ///
-    /// [CString]: std::ffi::CString
-    /// [CStr]: std::ffi::CStr
-    /// [OsStr]: std::ffi::OsStr
-    /// [Path]: std::path::Path
-    ///
-    /// # Errors
-    ///
-    /// Since a C `*char` is terminated by a NULL byte this conversion
-    /// will fail, when the [OsStr] has an interior null byte.  The
-    /// function will return
-    /// `[Err]([CStringError::InteriorNullByte])`.  When converting
-    /// from a [Path] it should be safe to
-    /// [`.unwrap()`](std::result::Result::unwrap) this anyway since a
-    /// [Path] should not contain interior null bytes.
-    ///
-    /// On windows when the string contains invalid Unicode
-    /// `[Err]([CStringError::NotUnicode])` is returned.
-    fn to_c_string(&self) -> Result<CString, CStringError>;
-}
-
-impl<T: AsRef<std::ffi::OsStr>> OsStrExt for T {
-    #[cfg(not(target_os = "windows"))]
-    fn to_c_string(&self) -> Result<CString, CStringError> {
-        use std::os::unix::ffi::OsStrExt;
-        CString::new(self.as_ref().as_bytes()).map_err(|err| match err {
-            std::ffi::NulError { .. } => CStringError::InteriorNullByte,
-        })
-    }
-
-    #[cfg(target_os = "windows")]
-    fn to_c_string(&self) -> Result<CString, CStringError> {
-        os_str_to_c_string_unicode(&self)
-    }
-}
-
-// Implementation for os_str_to_c_string on windows.
-#[allow(dead_code)]
-fn os_str_to_c_string_unicode(
-    os_str: &dyn AsRef<std::ffi::OsStr>,
-) -> Result<CString, CStringError> {
-    match os_str.as_ref().to_str() {
-        Some(val) => CString::new(val.as_bytes()).map_err(|err| match err {
-            std::ffi::NulError { .. } => CStringError::InteriorNullByte,
-        }),
-        None => Err(CStringError::NotUnicode),
-    }
-}
-
-/// Convenience methods/associated functions for working with [CString]
-///
-/// This is helps transitioning from unsafe code.
-pub trait CStringExt {
-    /// Create a new [CString], yolo style
-    ///
-    /// This unwrap the result, panicking when there are embedded NULL
-    /// bytes.
-    fn yolo<T: Into<Vec<u8>>>(t: T) -> CString {
-        CString::new(t).expect("String contains null byte, can not be CString")
-    }
-}
-
-impl CStringExt for CString {}
-
-/// Convenience methods to make transitioning from raw C strings easier.
-///
-/// To interact with (legacy) C APIs we often need to convert from
-/// Rust strings to raw C strings.  This can be clumsy to do correctly
-/// and the compiler sometimes allows it in an unsafe way.  These
-/// methods make it more succinct and help you get it right.
-pub trait StrExt {
-    /// Allocate a new raw C `*char` version of this string.
-    ///
-    /// This allocates a new raw C string which must be freed using
-    /// `free`.  It takes care of some common pitfalls with using
-    /// [CString.as_ptr].
-    ///
-    /// [CString.as_ptr]: std::ffi::CString.as_ptr
-    ///
-    /// # Panics
-    ///
-    /// This function will panic when the original string contains an
-    /// interior null byte as this can not be represented in raw C
-    /// strings.
-    unsafe fn strdup(&self) -> *mut libc::c_char;
-}
-
-impl<T: AsRef<str>> StrExt for T {
-    unsafe fn strdup(&self) -> *mut libc::c_char {
-        let tmp = CString::yolo(self.as_ref());
-        dc_strdup(tmp.as_ptr())
-    }
-}
-
-pub fn to_string_lossy(s: *const libc::c_char) -> String {
-    if s.is_null() {
-        return "".into();
-    }
-
-    let cstr = unsafe { CStr::from_ptr(s) };
-
-    cstr.to_string_lossy().to_string()
-}
-
-pub fn to_opt_string_lossy(s: *const libc::c_char) -> Option<String> {
-    if s.is_null() {
-        return None;
-    }
-
-    Some(to_string_lossy(s))
-}
-
-/// Convert a C `*char` pointer to a [std::path::Path] slice.
-///
-/// This converts a `*libc::c_char` pointer to a [Path] slice.  This
-/// essentially has to convert the pointer to [std::ffi::OsStr] to do
-/// so and thus is the inverse of [OsStrExt::to_c_string].  Just like
-/// [OsStrExt::to_c_string] requires valid Unicode on Windows, this
-/// requires that the pointer contains valid UTF-8 on Windows.
-///
-/// Because this returns a reference the [Path] silce can not outlive
-/// the original pointer.
-///
-/// [Path]: std::path::Path
-#[cfg(not(target_os = "windows"))]
-pub fn as_path<'a>(s: *const libc::c_char) -> &'a std::path::Path {
-    assert!(!s.is_null(), "cannot be used on null pointers");
-    use std::os::unix::ffi::OsStrExt;
-    unsafe {
-        let c_str = std::ffi::CStr::from_ptr(s).to_bytes();
-        let os_str = std::ffi::OsStr::from_bytes(c_str);
-        std::path::Path::new(os_str)
-    }
-}
-
-// as_path() implementation for windows, documented above.
-#[cfg(target_os = "windows")]
-pub fn as_path<'a>(s: *const libc::c_char) -> &'a std::path::Path {
-    as_path_unicode(s)
-}
-
-// Implementation for as_path() on Windows.
-//
-// Having this as a separate function means it can be tested on unix
-// too.
-#[allow(dead_code)]
-fn as_path_unicode<'a>(s: *const libc::c_char) -> &'a std::path::Path {
-    assert!(!s.is_null(), "cannot be used on null pointers");
-
-    let cstr = unsafe { CStr::from_ptr(s) };
-    let str = cstr.to_str().unwrap_or_else(|err| panic!("{}", err));
-
-    std::path::Path::new(str)
-}
-
 pub(crate) fn time() -> i64 {
     SystemTime::now()
         .duration_since(SystemTime::UNIX_EPOCH)
@@ -882,71 +579,14 @@ pub(crate) fn listflags_has(listflags: u32, bitindex: usize) -> bool {
     (listflags & bitindex) == bitindex
 }
 
-pub(crate) unsafe fn strdup(s: *const libc::c_char) -> *mut libc::c_char {
-    if s.is_null() {
-        return std::ptr::null_mut();
-    }
-
-    let slen = strlen(s);
-    let result = libc::malloc(slen + 1);
-    if result.is_null() {
-        return std::ptr::null_mut();
-    }
-
-    memcpy(result, s as *const _, slen + 1);
-    result as *mut _
-}
-
-pub(crate) unsafe fn strcasecmp(s1: *const libc::c_char, s2: *const libc::c_char) -> libc::c_int {
-    let s1 = std::ffi::CStr::from_ptr(s1)
-        .to_string_lossy()
-        .to_lowercase();
-    let s2 = std::ffi::CStr::from_ptr(s2)
-        .to_string_lossy()
-        .to_lowercase();
-    if s1 == s2 {
-        0
-    } else {
-        1
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
-
-    use libc::{free, strcmp};
     use std::convert::TryInto;
-    use std::ffi::CStr;
 
     use crate::constants::*;
     use crate::test_utils::*;
 
-    #[test]
-    fn test_dc_strdup() {
-        unsafe {
-            let str_a = b"foobar\x00" as *const u8 as *const libc::c_char;
-            let str_a_copy = dc_strdup(str_a);
-
-            // Value of str_a_copy should equal foobar
-            assert_eq!(
-                CStr::from_ptr(str_a_copy),
-                CString::new("foobar").unwrap().as_c_str()
-            );
-            // Address of str_a should be different from str_a_copy
-            assert_ne!(str_a, str_a_copy);
-
-            let str_a = std::ptr::null() as *const libc::c_char;
-            let str_a_copy = dc_strdup(str_a);
-            // Value of str_a_copy should equal ""
-            assert_eq!(
-                CStr::from_ptr(str_a_copy),
-                CString::new("").unwrap().as_c_str()
-            );
-            assert_ne!(str_a, str_a_copy);
-        }
-    }
-
     #[test]
     fn test_rust_ftoa() {
         assert_eq!("1.22", format!("{}", 1.22));
@@ -1007,44 +647,6 @@ mod tests {
         );
     }
 
-    /* calls free() for each item content */
-    unsafe fn clist_free_content(haystack: *const clist) {
-        let mut iter = (*haystack).first;
-
-        while !iter.is_null() {
-            free((*iter).data);
-            (*iter).data = ptr::null_mut();
-            iter = if !iter.is_null() {
-                (*iter).next
-            } else {
-                ptr::null_mut()
-            }
-        }
-    }
-
-    #[test]
-    fn test_dc_str_to_clist_1() {
-        unsafe {
-            let list = dc_str_to_clist("", " ");
-            assert_eq!((*list).count, 1);
-            clist_free_content(list);
-            clist_free(list);
-        }
-    }
-
-    #[test]
-    fn test_dc_str_to_clist_4() {
-        unsafe {
-            let list: *mut clist = dc_str_to_clist("foo bar test", " ");
-            assert_eq!((*list).count, 3);
-            let str = dc_str_from_clist(list, " ");
-            assert_eq!(str, "foo bar test");
-
-            clist_free_content(list);
-            clist_free(list);
-        }
-    }
-
     #[test]
     fn test_dc_create_id() {
         let buf = dc_create_id();
@@ -1072,113 +674,6 @@ mod tests {
     }
 
     #[test]
-    fn test_os_str_to_c_string_cwd() {
-        let some_dir = std::env::current_dir().unwrap();
-        some_dir.as_os_str().to_c_string().unwrap();
-    }
-
-    #[test]
-    fn test_os_str_to_c_string_unicode() {
-        let some_str = String::from("/some/valid/utf8");
-        let some_dir = std::path::Path::new(&some_str);
-        assert_eq!(
-            some_dir.as_os_str().to_c_string().unwrap(),
-            CString::new("/some/valid/utf8").unwrap()
-        );
-    }
-
-    #[test]
-    fn test_os_str_to_c_string_nul() {
-        let some_str = std::ffi::OsString::from("foo\x00bar");
-        assert_eq!(
-            some_str.to_c_string().err().unwrap(),
-            CStringError::InteriorNullByte
-        )
-    }
-
-    #[test]
-    fn test_path_to_c_string_cwd() {
-        let some_dir = std::env::current_dir().unwrap();
-        some_dir.to_c_string().unwrap();
-    }
-
-    #[test]
-    fn test_path_to_c_string_unicode() {
-        let some_str = String::from("/some/valid/utf8");
-        let some_dir = std::path::Path::new(&some_str);
-        assert_eq!(
-            some_dir.as_os_str().to_c_string().unwrap(),
-            CString::new("/some/valid/utf8").unwrap()
-        );
-    }
-
-    #[test]
-    fn test_os_str_to_c_string_unicode_fn() {
-        let some_str = std::ffi::OsString::from("foo");
-        assert_eq!(
-            os_str_to_c_string_unicode(&some_str).unwrap(),
-            CString::new("foo").unwrap()
-        );
-    }
-
-    #[test]
-    fn test_path_to_c_string_unicode_fn() {
-        let some_str = String::from("/some/path");
-        let some_path = std::path::Path::new(&some_str);
-        assert_eq!(
-            os_str_to_c_string_unicode(&some_path).unwrap(),
-            CString::new("/some/path").unwrap()
-        );
-    }
-
-    #[test]
-    fn test_os_str_to_c_string_unicode_fn_nul() {
-        let some_str = std::ffi::OsString::from("fooz\x00bar");
-        assert_eq!(
-            os_str_to_c_string_unicode(&some_str).err().unwrap(),
-            CStringError::InteriorNullByte
-        );
-    }
-
-    #[test]
-    fn test_as_path() {
-        let some_path = CString::new("/some/path").unwrap();
-        let ptr = some_path.as_ptr();
-        assert_eq!(as_path(ptr), std::ffi::OsString::from("/some/path"))
-    }
-
-    #[test]
-    fn test_as_path_unicode_fn() {
-        let some_path = CString::new("/some/path").unwrap();
-        let ptr = some_path.as_ptr();
-        assert_eq!(as_path_unicode(ptr), std::ffi::OsString::from("/some/path"));
-    }
-
-    #[test]
-    fn test_cstring_yolo() {
-        assert_eq!(CString::new("hello").unwrap(), CString::yolo("hello"));
-    }
-
-    #[test]
-    fn test_strdup_str() {
-        unsafe {
-            let s = "hello".strdup();
-            let cmp = strcmp(s, b"hello\x00" as *const u8 as *const libc::c_char);
-            free(s as *mut libc::c_void);
-            assert_eq!(cmp, 0);
-        }
-    }
-
-    #[test]
-    fn test_strdup_string() {
-        unsafe {
-            let s = String::from("hello").strdup();
-            let cmp = strcmp(s, b"hello\x00" as *const u8 as *const libc::c_char);
-            free(s as *mut libc::c_void);
-            assert_eq!(cmp, 0);
-        }
-    }
-
     #[test]
     fn test_dc_extract_grpid_from_rfc724_mid() {
         // Should return None if we pass invalid mid
@@ -1323,7 +818,7 @@ mod tests {
             dc_delete_file(context, "$BLOBDIR/foobar.dadada");
             dc_delete_file(context, "$BLOBDIR/foobar-folder");
         }
-        assert!(dc_write_file(context, "$BLOBDIR/foobar", b"content"));
+        assert!(dc_write_file(context, "$BLOBDIR/foobar", b"content").is_ok());
         assert!(dc_file_exist(context, "$BLOBDIR/foobar",));
         assert!(!dc_file_exist(context, "$BLOBDIR/foobarx"));
         assert_eq!(dc_get_filebytes(context, "$BLOBDIR/foobar"), 7);
@@ -1355,7 +850,7 @@ mod tests {
         assert!(!dc_delete_file(context, "$BLOBDIR/foobar-folder"));
 
         let fn0 = "$BLOBDIR/data.data";
-        assert!(dc_write_file(context, &fn0, b"content"));
+        assert!(dc_write_file(context, &fn0, b"content").is_ok());
 
         assert!(dc_delete_file(context, &fn0));
         assert!(!dc_file_exist(context, &fn0));

src/dehtml.rs

@@ -1,3 +1,7 @@
+//! De-HTML
+//!
+//! A module to remove HTML tags from the email text
+
 use lazy_static::lazy_static;
 use quick_xml;
 use quick_xml::events::{BytesEnd, BytesStart, BytesText};
@@ -19,22 +23,18 @@ enum AddText {
     YesPreserveLineEnds,
 }
 
-// dc_dehtml() returns way too many lineends; however, an optimisation on this issue is not needed as
-// the lineends are typically remove in further processing by the caller
-pub fn dc_dehtml(buf_terminated: &str) -> String {
-    let buf_terminated = buf_terminated.trim();
-
-    if buf_terminated.is_empty() {
-        return "".into();
-    }
+// dehtml() returns way too many newlines; however, an optimisation on this issue is not needed as
+// the newlines are typically removed in further processing by the caller
+pub fn dehtml(buf: &str) -> String {
+    let buf = buf.trim();
 
     let mut dehtml = Dehtml {
-        strbuilder: String::with_capacity(buf_terminated.len()),
+        strbuilder: String::with_capacity(buf.len()),
         add_text: AddText::YesRemoveLineEnds,
         last_href: None,
     };
 
-    let mut reader = quick_xml::Reader::from_str(buf_terminated);
+    let mut reader = quick_xml::Reader::from_str(buf);
 
     let mut buf = Vec::new();
 
@@ -171,7 +171,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_dc_dehtml() {
+    fn test_dehtml() {
         let cases = vec![
             (
                 "<a href='https://example.com'> Foo </a>",
@@ -186,7 +186,7 @@ mod tests {
             ("", ""),
         ];
         for (input, output) in cases {
-            assert_eq!(dc_dehtml(input), output);
+            assert_eq!(dehtml(input), output);
         }
     }
 }

src/e2ee.rs

@@ -1,41 +1,20 @@
 //! End-to-end encryption support.
 
 use std::collections::HashSet;
-use std::ptr;
-use std::str::FromStr;
 
-use libc::strlen;
-use mmime::clist::*;
-use mmime::mailimf::types::*;
-use mmime::mailimf::types_helper::*;
-use mmime::mailimf::*;
-use mmime::mailmime::content::*;
-use mmime::mailmime::types::*;
-use mmime::mailmime::types_helper::*;
-use mmime::mailmime::write_mem::*;
-use mmime::mailmime::*;
-use mmime::mailprivacy_prepare_mime;
-use mmime::mmapstring::*;
-use mmime::{mailmime_substitute, MAILIMF_NO_ERROR, MAIL_NO_ERROR};
+use mailparse::MailHeaderMap;
 use num_traits::FromPrimitive;
 
 use crate::aheader::*;
 use crate::config::Config;
 use crate::context::Context;
-use crate::dc_tools::*;
 use crate::error::*;
 use crate::key::*;
 use crate::keyring::*;
-use crate::mimefactory::MimeFactory;
 use crate::peerstate::*;
 use crate::pgp;
 use crate::securejoin::handle_degrade_event;
 use crate::wrapmime;
-use crate::wrapmime::*;
-
-// standard mime-version header aka b"Version: 1\r\n\x00"
-static mut VERSION_CONTENT: [libc::c_char; 13] =
-    [86, 101, 114, 115, 105, 111, 110, 58, 32, 49, 13, 10, 0];
 
 #[derive(Debug)]
 pub struct EncryptHelper {
@@ -71,39 +50,27 @@ impl EncryptHelper {
         Aheader::new(addr, pk, self.prefer_encrypt)
     }
 
-    pub fn try_encrypt(
-        &mut self,
-        factory: &mut MimeFactory,
+    /// Determines if we can and should encrypt.
+    pub fn should_encrypt(
+        &self,
+        context: &Context,
         e2ee_guaranteed: bool,
-        min_verified: PeerstateVerifiedStatus,
-        do_gossip: bool,
-        mut in_out_message: *mut Mailmime,
-        imffields_unprotected: *mut mailimf_fields,
+        peerstates: &[(Option<Peerstate>, &str)],
     ) -> Result<bool> {
-        // libEtPan's pgp_encrypt_mime() takes the parent as the new root.
-        // We just expect the root as being given to this function.
-        ensure!(
-            !in_out_message.is_null() && unsafe { (*in_out_message).mm_parent.is_null() },
-            "corrupted inputs"
-        );
-
         if !(self.prefer_encrypt == EncryptPreference::Mutual || e2ee_guaranteed) {
             return Ok(false);
         }
 
-        let context = &factory.context;
-        let mut keyring = Keyring::default();
-        let mut gossip_headers: Vec<String> = Vec::with_capacity(factory.recipients_addr.len());
-
-        // determine if we can and should encrypt
-        for recipient_addr in factory.recipients_addr.iter() {
-            if recipient_addr == &self.addr {
-                continue;
-            }
-            let peerstate = match Peerstate::from_addr(context, &context.sql, recipient_addr) {
-                Some(peerstate) => peerstate,
+        for (peerstate, addr) in peerstates {
+            match peerstate {
+                Some(peerstate) => {
+                    if peerstate.prefer_encrypt != EncryptPreference::Mutual && !e2ee_guaranteed {
+                        info!(context, "peerstate for {:?} is no-encrypt", addr);
+                        return Ok(false);
+                    }
+                }
                 None => {
-                    let msg = format!("peerstate for {} missing, cannot encrypt", recipient_addr);
+                    let msg = format!("peerstate for {:?} missing, cannot encrypt", addr);
                     if e2ee_guaranteed {
                         return Err(format_err!("{}", msg));
                     } else {
@@ -111,169 +78,62 @@ impl EncryptHelper {
                         return Ok(false);
                     }
                 }
-            };
-
-            if peerstate.prefer_encrypt != EncryptPreference::Mutual && !e2ee_guaranteed {
-                info!(context, "peerstate for {} is no-encrypt", recipient_addr);
-                return Ok(false);
-            }
-
-            if let Some(key) = peerstate.peek_key(min_verified) {
-                keyring.add_owned(key.clone());
-                if do_gossip {
-                    if let Some(header) = peerstate.render_gossip_header(min_verified) {
-                        gossip_headers.push(header.to_string());
-                    }
-                }
-            } else {
-                bail!(
-                    "proper enc-key for {} missing, cannot encrypt",
-                    recipient_addr
-                );
             }
         }
 
-        let sign_key = {
-            keyring.add_ref(&self.public_key);
-            let key = Key::from_self_private(context, self.addr.clone(), &context.sql);
-            ensure!(key.is_some(), "no own private key found");
+        Ok(true)
+    }
 
-            key
-        };
+    /// Tries to encrypt the passed in `mail`.
+    pub fn encrypt(
+        &mut self,
+        context: &Context,
+        min_verified: PeerstateVerifiedStatus,
+        mail_to_encrypt: lettre_email::PartBuilder,
+        peerstates: &[(Option<Peerstate>, &str)],
+    ) -> Result<String> {
+        let mut keyring = Keyring::default();
 
-        // encrypt message
-        unsafe {
-            mailprivacy_prepare_mime(in_out_message);
-            let mut part_to_encrypt = (*in_out_message).mm_data.mm_message.mm_msg_mime;
-            (*part_to_encrypt).mm_parent = ptr::null_mut();
-            let imffields_encrypted = mailimf_fields_new_empty();
-
-            // mailmime_new_message_data() calls mailmime_fields_new_with_version()
-            // which would add the unwanted MIME-Version:-header
-            let message_to_encrypt = mailmime_new_simple(
-                MAILMIME_MESSAGE as libc::c_int,
-                mailmime_fields_new_empty(),
-                mailmime_get_content_message(),
-                imffields_encrypted,
-                part_to_encrypt,
-            );
-
-            for header in &gossip_headers {
-                wrapmime::new_custom_field(imffields_encrypted, "Autocrypt-Gossip", &header)
-            }
-
-            // memoryhole headers: move some headers into encrypted part
-            // XXX note we can't use clist's into_iter() because the loop body also removes items
-            let mut cur = (*(*imffields_unprotected).fld_list).first;
-            while !cur.is_null() {
-                let field = (*cur).data as *mut mailimf_field;
-                let mut move_to_encrypted = false;
-
-                if !field.is_null() {
-                    if (*field).fld_type == MAILIMF_FIELD_SUBJECT as libc::c_int {
-                        move_to_encrypted = true;
-                    } else if (*field).fld_type == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int {
-                        let opt_field = (*field).fld_data.fld_optional_field;
-                        if !opt_field.is_null() && !(*opt_field).fld_name.is_null() {
-                            let fld_name = to_string_lossy((*opt_field).fld_name);
-                            if fld_name.starts_with("Secure-Join")
-                                || (fld_name.starts_with("Chat-") && fld_name != "Chat-Version")
-                            {
-                                move_to_encrypted = true;
-                            }
-                        }
-                    }
-                }
-
-                if move_to_encrypted {
-                    mailimf_fields_add(imffields_encrypted, field);
-                    cur = clist_delete((*imffields_unprotected).fld_list, cur);
-                } else {
-                    cur = (*cur).next;
-                }
-            }
-
-            let subject = mailimf_subject_new("...".strdup());
-            mailimf_fields_add(imffields_unprotected, mailimf_field_new_subject(subject));
-
-            wrapmime::append_ct_param(
-                (*part_to_encrypt).mm_content_type,
-                "protected-headers",
-                "v1",
-            )?;
-            let plain = mmap_string_new(b"\x00" as *const u8 as *const libc::c_char);
-            let mut col = 0;
-            mailmime_write_mem(plain, &mut col, message_to_encrypt);
-            mailmime_free(message_to_encrypt);
-
-            ensure!(
-                !(*plain).str_0.is_null() && (*plain).len > 0,
-                "could not write/allocate"
-            );
-
-            let ctext = pgp::pk_encrypt(
-                std::slice::from_raw_parts((*plain).str_0 as *const u8, (*plain).len),
-                &keyring,
-                sign_key.as_ref(),
-            );
-            mmap_string_free(plain);
-
-            let ctext_v = ctext?;
-
-            // create MIME-structure that will contain the encrypted text
-            let mut encrypted_part = new_data_part(
-                ptr::null_mut(),
-                0 as libc::size_t,
-                "multipart/encrypted",
-                MAILMIME_MECHANISM_BASE64,
-            )?;
-            let content = (*encrypted_part).mm_content_type;
-            wrapmime::append_ct_param(content, "protocol", "application/pgp-encrypted")?;
-
-            let version_mime = new_data_part(
-                VERSION_CONTENT.as_mut_ptr() as *mut libc::c_void,
-                strlen(VERSION_CONTENT.as_mut_ptr()),
-                "application/pgp-encrypted",
-                MAILMIME_MECHANISM_7BIT,
-            )?;
-            mailmime_smart_add_part(encrypted_part, version_mime);
-
-            // we assume that ctext_v is not dropped until the end
-            // of this if-scope
-            let ctext_part = new_data_part(
-                ctext_v.as_ptr() as *mut libc::c_void,
-                ctext_v.len(),
-                "application/octet-stream",
-                MAILMIME_MECHANISM_7BIT,
-            )?;
-
-            mailmime_smart_add_part(encrypted_part, ctext_part);
-            (*in_out_message).mm_data.mm_message.mm_msg_mime = encrypted_part;
-            (*encrypted_part).mm_parent = in_out_message;
-            let gossiped = !&gossip_headers.is_empty();
-            factory.finalize_mime_message(in_out_message, true, gossiped)?;
-
-            Ok(true)
+        for (peerstate, addr) in peerstates
+            .iter()
+            .filter_map(|(state, addr)| state.as_ref().map(|s| (s, addr)))
+        {
+            info!(context, "adding for {}: {:?}", addr, peerstate);
+            let key = peerstate.peek_key(min_verified).ok_or_else(|| {
+                format_err!("proper enc-key for {} missing, cannot encrypt", addr)
+            })?;
+            keyring.add_ref(key);
         }
+
+        keyring.add_ref(&self.public_key);
+        let sign_key = Key::from_self_private(context, self.addr.clone(), &context.sql)
+            .ok_or_else(|| format_err!("missing own private key"))?;
+
+        let raw_message = mail_to_encrypt.build().as_string().into_bytes();
+
+        let ctext = pgp::pk_encrypt(&raw_message, &keyring, Some(&sign_key))?;
+
+        Ok(ctext)
     }
 }
 
 pub fn try_decrypt(
     context: &Context,
-    in_out_message: *mut Mailmime,
-) -> Result<(bool, HashSet<String>, HashSet<String>)> {
-    // just a pointer into mailmime structure, must not be freed
-    let imffields = mailmime_find_mailimf_fields(in_out_message);
-    ensure!(
-        !in_out_message.is_null() && !imffields.is_null(),
-        "corrupt invalid mime inputs"
-    );
+    mail: &mailparse::ParsedMail<'_>,
+    message_time: i64,
+) -> Result<(Option<Vec<u8>>, HashSet<String>)> {
+    info!(context, "trying to decrypt");
 
-    let from = wrapmime::get_field_from(imffields)?;
-    let message_time = wrapmime::get_field_date(imffields)?;
+    let from = mail
+        .headers
+        .get_first_value("From")?
+        .and_then(|from_addr| mailparse::addrparse(&from_addr).ok())
+        .and_then(|from| from.extract_single_info())
+        .map(|from| from.addr)
+        .unwrap_or_default();
 
     let mut peerstate = None;
-    let autocryptheader = Aheader::from_imffields(&from, imffields);
+    let autocryptheader = Aheader::from_headers(context, &from, &mail.headers);
 
     if message_time > 0 {
         peerstate = Peerstate::from_addr(context, &context.sql, &from);
@@ -282,9 +142,7 @@ pub fn try_decrypt(
             if let Some(ref header) = autocryptheader {
                 peerstate.apply_header(&header, message_time);
                 peerstate.save_to_db(&context.sql, false)?;
-            } else if message_time > peerstate.last_seen_autocrypt
-                && !contains_report(in_out_message)
-            {
+            } else if message_time > peerstate.last_seen_autocrypt && !contains_report(mail) {
                 peerstate.degrade_encryption(message_time);
                 peerstate.save_to_db(&context.sql, false)?;
             }
@@ -294,13 +152,12 @@ pub fn try_decrypt(
             peerstate = Some(p);
         }
     }
+
     /* possibly perform decryption */
     let mut private_keyring = Keyring::default();
     let mut public_keyring_for_validate = Keyring::default();
-    let mut encrypted = false;
+    let mut out_mail = None;
     let mut signatures = HashSet::default();
-    let mut gossipped_addr = HashSet::default();
-
     let self_addr = context.get_config(Config::ConfiguredAddr);
 
     if let Some(self_addr) = self_addr {
@@ -320,60 +177,16 @@ pub fn try_decrypt(
                 }
             }
 
-            let mut gossip_headers = ptr::null_mut();
-            encrypted = decrypt_if_autocrypt_message(
+            out_mail = decrypt_if_autocrypt_message(
                 context,
-                in_out_message,
+                mail,
                 &private_keyring,
                 &public_keyring_for_validate,
                 &mut signatures,
-                &mut gossip_headers,
             )?;
-            if !gossip_headers.is_null() {
-                gossipped_addr =
-                    update_gossip_peerstates(context, message_time, imffields, gossip_headers)?;
-                unsafe { mailimf_fields_free(gossip_headers) };
-            }
         }
     }
-    Ok((encrypted, signatures, gossipped_addr))
-}
-
-fn new_data_part(
-    data: *mut libc::c_void,
-    data_bytes: libc::size_t,
-    content_type: &str,
-    default_encoding: u32,
-) -> Result<*mut Mailmime> {
-    let content = new_content_type(&content_type)?;
-    let mut encoding = ptr::null_mut();
-    if wrapmime::content_type_needs_encoding(content) {
-        encoding = unsafe { mailmime_mechanism_new(default_encoding as i32, ptr::null_mut()) };
-        ensure!(!encoding.is_null(), "failed to create encoding");
-    }
-    let mime_fields = {
-        unsafe {
-            mailmime_fields_new_with_data(
-                encoding,
-                ptr::null_mut(),
-                ptr::null_mut(),
-                ptr::null_mut(),
-                ptr::null_mut(),
-            )
-        }
-    };
-    ensure!(!mime_fields.is_null(), "internal mime error");
-
-    let mime = unsafe { mailmime_new_empty(content, mime_fields) };
-    ensure!(!mime.is_null(), "internal mime error");
-
-    if unsafe { (*mime).mm_type } == MAILMIME_SINGLE as libc::c_int {
-        if !data.is_null() && data_bytes > 0 {
-            unsafe { mailmime_set_body_text(mime, data as *mut libc::c_char, data_bytes) };
-        }
-    }
-
-    Ok(mime)
+    Ok((out_mail, signatures))
 }
 
 /// Load public key from database or generate a new one.
@@ -423,204 +236,65 @@ fn load_or_generate_self_public_key(context: &Context, self_addr: impl AsRef<str
     }
 }
 
-fn update_gossip_peerstates(
+fn decrypt_if_autocrypt_message<'a>(
     context: &Context,
-    message_time: i64,
-    imffields: *mut mailimf_fields,
-    gossip_headers: *const mailimf_fields,
-) -> Result<HashSet<String>> {
-    // XXX split the parsing from the modification part
-    let mut recipients: Option<HashSet<String>> = None;
-    let mut gossipped_addr: HashSet<String> = Default::default();
-
-    for cur_data in unsafe { (*(*gossip_headers).fld_list).into_iter() } {
-        let field = cur_data as *mut mailimf_field;
-        if field.is_null() {
-            continue;
-        }
-
-        let field = unsafe { *field };
-
-        if field.fld_type == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int {
-            let optional_field = unsafe { field.fld_data.fld_optional_field };
-            if optional_field.is_null() {
-                continue;
-            }
-
-            let optional_field = unsafe { *optional_field };
-            if !optional_field.fld_name.is_null()
-                && to_string_lossy(optional_field.fld_name) == "Autocrypt-Gossip"
-            {
-                let value = to_string_lossy(optional_field.fld_value);
-                let gossip_header = Aheader::from_str(&value);
-
-                if let Ok(ref header) = gossip_header {
-                    if recipients.is_none() {
-                        recipients = Some(mailimf_get_recipients(imffields));
-                    }
-                    if recipients.as_ref().unwrap().contains(&header.addr) {
-                        let mut peerstate =
-                            Peerstate::from_addr(context, &context.sql, &header.addr);
-                        if let Some(ref mut peerstate) = peerstate {
-                            peerstate.apply_gossip(header, message_time);
-                            peerstate.save_to_db(&context.sql, false)?;
-                        } else {
-                            let p = Peerstate::from_gossip(context, header, message_time);
-                            p.save_to_db(&context.sql, true)?;
-                            peerstate = Some(p);
-                        }
-                        if let Some(peerstate) = peerstate {
-                            if peerstate.degrade_event.is_some() {
-                                handle_degrade_event(context, &peerstate)?;
-                            }
-                        }
-
-                        gossipped_addr.insert(header.addr.clone());
-                    } else {
-                        info!(
-                            context,
-                            "Ignoring gossipped \"{}\" as the address is not in To/Cc list.",
-                            &header.addr,
-                        );
-                    }
-                }
-            }
-        }
-    }
-
-    Ok(gossipped_addr)
-}
-
-fn decrypt_if_autocrypt_message(
-    context: &Context,
-    mime_undetermined: *mut Mailmime,
+    mail: &mailparse::ParsedMail<'a>,
     private_keyring: &Keyring,
     public_keyring_for_validate: &Keyring,
     ret_valid_signatures: &mut HashSet<String>,
-    ret_gossip_headers: *mut *mut mailimf_fields,
-) -> 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
-    if it was not an Autocrypt message.
+) -> Result<Option<Vec<u8>>> {
+    //  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
+    // if it was not an Autocrypt message.
+    //
+    // Errors are returned for failures related to decryption of AC-messages.
 
-    Errors are returned for failures related to decryption of AC-messages.
-    */
-    ensure!(!mime_undetermined.is_null(), "Invalid mime reference");
-
-    let (mime, encrypted_data_part) = match wrapmime::get_autocrypt_mime(mime_undetermined) {
-        Err(_) => {
+    let encrypted_data_part = match wrapmime::get_autocrypt_mime(mail) {
+        Err(err) => {
             // not a proper autocrypt message, abort and ignore
-            return Ok(false);
+            warn!(context, "Invalid autocrypt message: {:?}", err);
+            return Ok(None);
         }
         Ok(res) => res,
     };
 
-    let decrypted_mime = decrypt_part(
+    decrypt_part(
         context,
         encrypted_data_part,
         private_keyring,
         public_keyring_for_validate,
         ret_valid_signatures,
-    )?;
-    // decrypted_mime is a dangling pointer which we now put into mailmime's Ownership
-    unsafe {
-        mailmime_substitute(mime, decrypted_mime);
-        mailmime_free(mime);
-    }
-
-    // finally, let's also return gossip headers
-    // XXX better return parsed headers so that upstream
-    // does not need to dive into mmime-stuff again.
-    unsafe {
-        if (*ret_gossip_headers).is_null() && !ret_valid_signatures.is_empty() {
-            let mut dummy: libc::size_t = 0;
-            let mut test: *mut mailimf_fields = ptr::null_mut();
-            if mailimf_envelope_and_optional_fields_parse(
-                (*decrypted_mime).mm_mime_start,
-                (*decrypted_mime).mm_length,
-                &mut dummy,
-                &mut test,
-            ) == MAILIMF_NO_ERROR as libc::c_int
-                && !test.is_null()
-            {
-                *ret_gossip_headers = test;
-            }
-        }
-    }
-
-    Ok(true)
+    )
 }
 
+/// Returns Ok(None) if nothing encrypted was found.
 fn decrypt_part(
-    _context: &Context,
-    mime: *mut Mailmime,
+    context: &Context,
+    mail: &mailparse::ParsedMail<'_>,
     private_keyring: &Keyring,
     public_keyring_for_validate: &Keyring,
     ret_valid_signatures: &mut HashSet<String>,
-) -> Result<*mut Mailmime> {
-    let mime_data: *mut mailmime_data;
-    let mut mime_transfer_encoding = MAILMIME_MECHANISM_BINARY as libc::c_int;
-
-    unsafe {
-        mime_data = (*mime).mm_data.mm_single;
-    }
-    if !wrapmime::has_decryptable_data(mime_data) {
-        return Ok(ptr::null_mut());
-    }
-
-    if let Some(enc) = wrapmime::get_mime_transfer_encoding(mime) {
-        mime_transfer_encoding = enc;
-    }
-
-    let data: Vec<u8> = wrapmime::decode_dt_data(mime_data, mime_transfer_encoding)?;
-
-    let mut ret_decrypted_mime = ptr::null_mut();
+) -> Result<Option<Vec<u8>>> {
+    info!(context, "decrypting part");
+    let data = mail.get_body_raw()?;
 
     if has_decrypted_pgp_armor(&data) {
         // we should only have one decryption happening
         ensure!(ret_valid_signatures.is_empty(), "corrupt signatures");
 
-        let plain = match pgp::pk_decrypt(
+        let plain = pgp::pk_decrypt(
             &data,
             &private_keyring,
             &public_keyring_for_validate,
             Some(ret_valid_signatures),
-        ) {
-            Ok(plain) => {
-                ensure!(!ret_valid_signatures.is_empty(), "no valid signatures");
-                plain
-            }
-            Err(err) => bail!("could not decrypt: {}", err),
-        };
-        let plain_bytes = plain.len();
-        let plain_buf = plain.as_ptr() as *const libc::c_char;
+        )?;
 
-        let mut index = 0;
-        let mut decrypted_mime = ptr::null_mut();
-        if unsafe {
-            mailmime_parse(
-                plain_buf as *const _,
-                plain_bytes,
-                &mut index,
-                &mut decrypted_mime,
-            )
-        } != MAIL_NO_ERROR as libc::c_int
-            || decrypted_mime.is_null()
-        {
-            if !decrypted_mime.is_null() {
-                unsafe { mailmime_free(decrypted_mime) };
-            }
-        } else {
-            // decrypted_mime points into `plain`.
-            // FIXME(@dignifiedquire): this still leaks memory I believe, as mailmime_free
-            // does not free the underlying buffer. But for now we have to live with it
-            std::mem::forget(plain);
-            ret_decrypted_mime = decrypted_mime;
-        }
+        ensure!(!ret_valid_signatures.is_empty(), "no valid signatures");
+        return Ok(Some(plain));
     }
 
-    Ok(ret_decrypted_mime)
+    Ok(None)
 }
 
 fn has_decrypted_pgp_armor(input: &[u8]) -> bool {
@@ -644,36 +318,8 @@ fn has_decrypted_pgp_armor(input: &[u8]) -> bool {
 /// However, Delta Chat itself has no problem with encrypted multipart/report
 /// parts and MUAs should be encouraged to encrpyt multipart/reports as well so
 /// that we could use the normal Autocrypt processing.
-fn contains_report(mime: *mut Mailmime) -> bool {
-    assert!(!mime.is_null());
-    let mime = unsafe { *mime };
-
-    if mime.mm_type == MAILMIME_MULTIPLE as libc::c_int {
-        let tp_type = unsafe { (*(*mime.mm_content_type).ct_type).tp_type };
-        let ct_type =
-            unsafe { (*(*(*mime.mm_content_type).ct_type).tp_data.tp_composite_type).ct_type };
-
-        if tp_type == MAILMIME_TYPE_COMPOSITE_TYPE as libc::c_int
-            && ct_type == MAILMIME_COMPOSITE_TYPE_MULTIPART as libc::c_int
-            && to_string_lossy(unsafe { (*mime.mm_content_type).ct_subtype }) == "report"
-        {
-            return true;
-        }
-
-        for cur_data in unsafe { (*(*mime.mm_mime_fields).fld_list).into_iter() } {
-            if contains_report(cur_data as *mut Mailmime) {
-                return true;
-            }
-        }
-    } else if mime.mm_type == MAILMIME_MESSAGE as libc::c_int {
-        let m = unsafe { mime.mm_data.mm_message.mm_msg_mime };
-
-        if contains_report(m) {
-            return true;
-        }
-    }
-
-    false
+fn contains_report(mail: &mailparse::ParsedMail<'_>) -> bool {
+    mail.ctype.mimetype == "multipart/report"
 }
 
 /// Ensures a private key exists for the configured user.
@@ -699,7 +345,6 @@ pub fn ensure_secret_key_exists(context: &Context) -> Result<String> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use libc::free;
 
     use crate::test_utils::*;
 
@@ -722,7 +367,7 @@ mod tests {
 
     #[test]
     fn test_mailmime_parse() {
-        let plain = b"Chat-Disposition-Notification-To: holger@deltachat.de
+        let plain = b"Chat-Disposition-Notification-To: hello@world.de
 Chat-Group-ID: CovhGgau8M-
 Chat-Group-Name: Delta Chat Dev
 Subject: =?utf-8?Q?Chat=3A?= Delta Chat =?utf-8?Q?Dev=3A?= sidenote for
@@ -730,35 +375,18 @@ Subject: =?utf-8?Q?Chat=3A?= Delta Chat =?utf-8?Q?Dev=3A?= sidenote for
 Content-Type: text/plain; charset=\"utf-8\"; protected-headers=\"v1\"
 Content-Transfer-Encoding: quoted-printable
 
-sidenote for all: rust core master is broken currently ... so dont recomm=
-end to try to run with desktop or ios unless you are ready to hunt bugs
+sidenote for all: things are trick atm recomm=
+end not to try to run with desktop or ios unless you are ready to hunt bugs
 
 -- =20
 Sent with my Delta Chat Messenger: https://delta.chat";
-        let plain_bytes = plain.len();
-        let plain_buf = plain.as_ptr() as *const libc::c_char;
+        let mail = mailparse::parse_mail(plain).expect("failed to parse valid message");
 
-        let mut index = 0;
-        let mut decrypted_mime = std::ptr::null_mut();
-
-        let res = unsafe {
-            mailmime_parse(
-                plain_buf as *const _,
-                plain_bytes,
-                &mut index,
-                &mut decrypted_mime,
-            )
-        };
-        unsafe {
-            let msg1 = (*decrypted_mime).mm_data.mm_message.mm_msg_mime;
-            let data = mailmime_transfer_decode(msg1).unwrap();
-            println!("{:?}", String::from_utf8_lossy(&data));
-        }
-
-        assert_eq!(res, 0);
-        assert!(!decrypted_mime.is_null());
-
-        unsafe { free(decrypted_mime as *mut _) };
+        assert_eq!(mail.headers.len(), 6);
+        assert!(
+            mail.get_body().unwrap().starts_with(
+                "sidenote for all: things are trick atm recommend not to try to run with desktop or ios unless you are ready to hunt bugs")
+        );
     }
 
     mod load_or_generate_self_public_key {

src/error.rs

@@ -1,19 +1,12 @@
 use failure::Fail;
+use lettre_email::mime;
 
 #[derive(Debug, Fail)]
 pub enum Error {
-    #[fail(display = "Sqlite Error: {:?}", _0)]
-    Sql(rusqlite::Error),
-    #[fail(display = "Sqlite Connection Pool Error: {:?}", _0)]
-    ConnectionPool(r2d2::Error),
     #[fail(display = "{:?}", _0)]
     Failure(failure::Error),
-    #[fail(display = "Sqlite: Connection closed")]
-    SqlNoConnection,
-    #[fail(display = "Sqlite: Already open")]
-    SqlAlreadyOpen,
-    #[fail(display = "Sqlite: Failed to open")]
-    SqlFailedToOpen,
+    #[fail(display = "SQL error: {:?}", _0)]
+    SqlError(#[cause] crate::sql::Error),
     #[fail(display = "{:?}", _0)]
     Io(std::io::Error),
     #[fail(display = "{:?}", _0)]
@@ -22,8 +15,6 @@ pub enum Error {
     Image(image_meta::ImageError),
     #[fail(display = "{:?}", _0)]
     Utf8(std::str::Utf8Error),
-    #[fail(display = "{:?}", _0)]
-    CStringError(crate::dc_tools::CStringError),
     #[fail(display = "PGP: {:?}", _0)]
     Pgp(pgp::errors::Error),
     #[fail(display = "Base64Decode: {:?}", _0)]
@@ -36,31 +27,19 @@ pub enum Error {
     InvalidMsgId,
     #[fail(display = "Watch folder not found {:?}", _0)]
     WatchFolderNotFound(String),
-    #[fail(display = "Connection Failed params: {}", _0)]
-    ImapConnectionFailed(String),
-    #[fail(display = "Could not get OAUTH token")]
-    ImapOauthError,
-    #[fail(display = "Could not login as {}", _0)]
-    ImapLoginFailed(String),
-    #[fail(display = "Cannot idle")]
-    ImapMissesIdle,
-    #[fail(display = "Imap IDLE protocol failed to init/complete")]
-    ImapIdleProtocolFailed(String),
-    #[fail(display = "Imap IDLE failed to select folder {:?}", _0)]
-    ImapSelectFailed(String),
-    #[fail(display = "Connect without configured params")]
-    ConnectWithoutConfigure,
-    #[fail(display = "imap operation attempted while imap is torn down")]
-    ImapInTeardown,
-    #[fail(display = "No IMAP Connection established")]
-    ImapNoConnection,
+    #[fail(display = "Inalid Email: {:?}", _0)]
+    MailParseError(#[cause] mailparse::MailParseError),
+    #[fail(display = "Building invalid Email: {:?}", _0)]
+    LettreError(#[cause] lettre_email::error::Error),
+    #[fail(display = "FromStr error: {:?}", _0)]
+    FromStr(#[cause] mime::FromStrError),
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
 
-impl From<rusqlite::Error> for Error {
-    fn from(err: rusqlite::Error) -> Error {
-        Error::Sql(err)
+impl From<crate::sql::Error> for Error {
+    fn from(err: crate::sql::Error) -> Error {
+        Error::SqlError(err)
     }
 }
 
@@ -76,12 +55,6 @@ impl From<failure::Error> for Error {
     }
 }
 
-impl From<r2d2::Error> for Error {
-    fn from(err: r2d2::Error) -> Error {
-        Error::ConnectionPool(err)
-    }
-}
-
 impl From<std::io::Error> for Error {
     fn from(err: std::io::Error) -> Error {
         Error::Io(err)
@@ -100,12 +73,6 @@ impl From<image_meta::ImageError> for Error {
     }
 }
 
-impl From<crate::dc_tools::CStringError> for Error {
-    fn from(err: crate::dc_tools::CStringError) -> Error {
-        Error::CStringError(err)
-    }
-}
-
 impl From<pgp::errors::Error> for Error {
     fn from(err: pgp::errors::Error) -> Error {
         Error::Pgp(err)
@@ -130,6 +97,24 @@ impl From<crate::message::InvalidMsgId> for Error {
     }
 }
 
+impl From<mailparse::MailParseError> for Error {
+    fn from(err: mailparse::MailParseError) -> Error {
+        Error::MailParseError(err)
+    }
+}
+
+impl From<lettre_email::error::Error> for Error {
+    fn from(err: lettre_email::error::Error) -> Error {
+        Error::LettreError(err)
+    }
+}
+
+impl From<mime::FromStrError> for Error {
+    fn from(err: mime::FromStrError) -> Error {
+        Error::FromStr(err)
+    }
+}
+
 #[macro_export]
 macro_rules! bail {
     ($e:expr) => {

src/imap.rs

@@ -18,7 +18,6 @@ use async_std::task;
 use crate::constants::*;
 use crate::context::Context;
 use crate::dc_receive_imf::dc_receive_imf;
-use crate::error::{Error, Result};
 use crate::events::Event;
 use crate::imap_client::*;
 use crate::job::{job_add, Action};
@@ -31,6 +30,77 @@ use crate::wrapmime;
 
 const DC_IMAP_SEEN: usize = 0x0001;
 
+type Result<T> = std::result::Result<T, Error>;
+
+#[derive(Debug, Fail)]
+pub enum Error {
+    #[fail(display = "IMAP Could not obtain imap-session object.")]
+    NoSession,
+
+    #[fail(display = "IMAP Connect without configured params")]
+    ConnectWithoutConfigure,
+
+    #[fail(display = "IMAP Connection Failed params: {}", _0)]
+    ConnectionFailed(String),
+
+    #[fail(display = "IMAP No Connection established")]
+    NoConnection,
+
+    #[fail(display = "IMAP Could not get OAUTH token")]
+    OauthError,
+
+    #[fail(display = "IMAP Could not login as {}", _0)]
+    LoginFailed(String),
+
+    #[fail(display = "IMAP Could not fetch {}", _0)]
+    FetchFailed(#[cause] async_imap::error::Error),
+
+    #[fail(display = "IMAP IDLE protocol failed to init/complete")]
+    IdleProtocolFailed(#[cause] async_imap::error::Error),
+
+    #[fail(display = "IMAP server does not have IDLE capability")]
+    IdleAbilityMissing,
+
+    #[fail(display = "IMAP Connection Lost or no connection established")]
+    ConnectionLost,
+
+    #[fail(display = "IMAP close/expunge failed: {}", _0)]
+    CloseExpungeFailed(#[cause] async_imap::error::Error),
+
+    #[fail(display = "IMAP Folder name invalid: {:?}", _0)]
+    BadFolderName(String),
+
+    #[fail(display = "IMAP operation attempted while it is torn down")]
+    InTeardown,
+
+    #[fail(display = "IMAP operation attempted while it is torn down")]
+    SqlError(#[cause] crate::sql::Error),
+
+    #[fail(display = "IMAP got error from elsewhere: {:?}", _0)]
+    WrappedError(#[cause] crate::error::Error),
+
+    #[fail(display = "IMAP other error: {:?}", _0)]
+    Other(String),
+}
+
+impl From<crate::sql::Error> for Error {
+    fn from(err: crate::sql::Error) -> Error {
+        Error::SqlError(err)
+    }
+}
+
+impl From<crate::error::Error> for Error {
+    fn from(err: crate::error::Error) -> Error {
+        Error::WrappedError(err)
+    }
+}
+
+impl From<Error> for crate::error::Error {
+    fn from(err: Error) -> crate::error::Error {
+        crate::error::Error::Message(err.to_string())
+    }
+}
+
 #[derive(Debug, Display, Clone, Copy, PartialEq, Eq)]
 pub enum ImapActionResult {
     Failed,
@@ -40,6 +110,7 @@ pub enum ImapActionResult {
 }
 
 const PREFETCH_FLAGS: &str = "(UID ENVELOPE)";
+const JUST_UID: &str = "(UID)";
 const BODY_FLAGS: &str = "(FLAGS BODY.PEEK[])";
 const SELECT_ALL: &str = "1:*";
 
@@ -141,7 +212,7 @@ impl Imap {
     fn setup_handle_if_needed(&self, context: &Context) -> Result<()> {
         task::block_on(async move {
             if self.config.read().await.imap_server.is_empty() {
-                return Err(Error::ImapInTeardown);
+                return Err(Error::InTeardown);
             }
 
             if self.should_reconnect() {
@@ -203,7 +274,7 @@ impl Imap {
                             let res = client.authenticate("XOAUTH2", &auth).await;
                             res
                         } else {
-                            return Err(Error::ImapOauthError);
+                            return Err(Error::OauthError);
                         }
                     } else {
                         let res = client.login(imap_user, imap_pw).await;
@@ -223,7 +294,7 @@ impl Imap {
                     };
                     // IMAP connection failures are reported to users
                     emit_event!(context, Event::ErrorNetwork(message));
-                    return Err(Error::ImapConnectionFailed(err.to_string()));
+                    return Err(Error::ConnectionFailed(err.to_string()));
                 }
             };
 
@@ -244,10 +315,7 @@ impl Imap {
                         Event::ErrorNetwork(format!("{} ({})", message, err))
                     );
                     self.trigger_reconnect();
-                    Err(Error::ImapLoginFailed(format!(
-                        "cannot login as {}",
-                        imap_user
-                    )))
+                    Err(Error::LoginFailed(format!("cannot login as {}", imap_user)))
                 }
             }
         })
@@ -299,19 +367,10 @@ impl Imap {
         // the trailing underscore is correct
 
         if self.connect(context, &param) {
-            if context
-                .sql
-                .get_raw_config_int(context, "folders_configured")
-                .unwrap_or_default()
-                < 3
-            {
-                self.configure_folders(context, true);
-            }
-            return Ok(());
+            self.ensure_configured_folders(context, true)
+        } else {
+            Err(Error::ConnectionFailed(format!("{}", param).to_string()))
         }
-        return Err(Error::ImapConnectionFailed(
-            format!("{}", param).to_string(),
-        ));
     }
 
     /// tries connecting to imap account using the specific login
@@ -400,30 +459,30 @@ impl Imap {
         task::block_on(async move {
             if !context.sql.is_open() {
                 // probably shutdown
-                return Err(Error::ImapInTeardown);
+                return Err(Error::InTeardown);
             }
             while self
                 .fetch_from_single_folder(context, &watch_folder)
                 .await?
             {
-                // During the fetch commands new messages may arrive.  So we fetch until we do not
-                // get any more. If IDLE is called directly after, there is only a small chance that
-                // messages are missed and delayed until the next IDLE call
+                // We fetch until no more new messages are there.
             }
             Ok(())
         })
     }
 
+    /// select a folder, possibly update uid_validity and, if needed,
+    /// expunge the folder to remove delete-marked messages.
     async fn select_folder<S: AsRef<str>>(
         &self,
         context: &Context,
         folder: Option<S>,
-    ) -> ImapActionResult {
+    ) -> Result<()> {
         if self.session.lock().await.is_none() {
             let mut cfg = self.config.write().await;
             cfg.selected_folder = None;
             cfg.selected_folder_needs_expunge = false;
-            return ImapActionResult::Failed;
+            return Err(Error::NoSession);
         }
 
         // if there is a new folder and the new folder is equal to the selected one, there's nothing to do.
@@ -431,7 +490,7 @@ impl Imap {
         if let Some(ref folder) = folder {
             if let Some(ref selected_folder) = self.config.read().await.selected_folder {
                 if folder.as_ref() == selected_folder {
-                    return ImapActionResult::AlreadyDone;
+                    return Ok(());
                 }
             }
         }
@@ -450,12 +509,11 @@ impl Imap {
                             info!(context, "close/expunge succeeded");
                         }
                         Err(err) => {
-                            warn!(context, "failed to close session: {:?}", err);
-                            return ImapActionResult::Failed;
+                            return Err(Error::CloseExpungeFailed(err));
                         }
                     }
                 } else {
-                    return ImapActionResult::Failed;
+                    return Err(Error::NoSession);
                 }
             }
             self.config.write().await.selected_folder_needs_expunge = false;
@@ -464,31 +522,39 @@ impl Imap {
         // select new folder
         if let Some(ref folder) = folder {
             if let Some(ref mut session) = &mut *self.session.lock().await {
-                match session.select(folder).await {
+                let res = session.select(folder).await;
+
+                // https://tools.ietf.org/html/rfc3501#section-6.3.1
+                // says that if the server reports select failure we are in
+                // authenticated (not-select) state.
+
+                match res {
                     Ok(mailbox) => {
                         let mut config = self.config.write().await;
                         config.selected_folder = Some(folder.as_ref().to_string());
                         config.selected_mailbox = Some(mailbox);
+                        Ok(())
+                    }
+                    Err(async_imap::error::Error::ConnectionLost) => {
+                        self.trigger_reconnect();
+                        self.config.write().await.selected_folder = None;
+                        Err(Error::ConnectionLost)
+                    }
+                    Err(async_imap::error::Error::Validate(_)) => {
+                        Err(Error::BadFolderName(folder.as_ref().to_string()))
                     }
                     Err(err) => {
-                        warn!(
-                            context,
-                            "Cannot select folder: {}; {:?}.",
-                            folder.as_ref(),
-                            err
-                        );
-
                         self.config.write().await.selected_folder = None;
                         self.trigger_reconnect();
-                        return ImapActionResult::Failed;
+                        Err(Error::Other(err.to_string()))
                     }
                 }
             } else {
-                unreachable!();
+                Err(Error::NoSession)
             }
+        } else {
+            Ok(())
         }
-
-        ImapActionResult::Success
     }
 
     fn get_config_last_seen_uid<S: AsRef<str>>(&self, context: &Context, folder: S) -> (u32, u32) {
@@ -513,140 +579,154 @@ impl Imap {
         }
     }
 
-    async fn fetch_from_single_folder<S: AsRef<str>>(
+    /// return Result with (uid_validity, last_seen_uid) tuple.
+    pub(crate) fn select_with_uidvalidity(
         &self,
         context: &Context,
-        folder: S,
-    ) -> Result<bool> {
-        match self.select_folder(context, Some(&folder)).await {
-            ImapActionResult::Failed | ImapActionResult::RetryLater => {
-                bail!("Cannot select folder {:?} for fetching.", folder.as_ref());
+        folder: &str,
+    ) -> Result<(u32, u32)> {
+        task::block_on(async move {
+            self.select_folder(context, Some(folder)).await?;
+
+            // compare last seen UIDVALIDITY against the current one
+            let (uid_validity, last_seen_uid) = self.get_config_last_seen_uid(context, &folder);
+
+            let config = self.config.read().await;
+            let mailbox = config.selected_mailbox.as_ref().expect("just selected");
+
+            let new_uid_validity = match mailbox.uid_validity {
+                Some(v) => v,
+                None => {
+                    let s = format!("No UIDVALIDITY for folder {:?}", folder);
+                    return Err(Error::Other(s));
+                }
+            };
+
+            if new_uid_validity == uid_validity {
+                return Ok((uid_validity, last_seen_uid));
             }
-            ImapActionResult::Success | ImapActionResult::AlreadyDone => {}
-        }
-
-        // compare last seen UIDVALIDITY against the current one
-        let (mut uid_validity, mut last_seen_uid) = self.get_config_last_seen_uid(context, &folder);
-
-        let config = self.config.read().await;
-        let mailbox = config.selected_mailbox.as_ref().expect("just selected");
-
-        ensure!(
-            mailbox.uid_validity.is_some(),
-            "Cannot get UIDVALIDITY for folder {:?}",
-            folder.as_ref()
-        );
-
-        let new_uid_validity = mailbox.uid_validity.unwrap();
-        if new_uid_validity != uid_validity {
-            // First time this folder is selected or UIDVALIDITY has changed.
-            // Init lastseenuid and save it to config.
-            info!(
-                context,
-                "new_uid_validity={} current local uid_validity={} lastseenuid={}",
-                new_uid_validity,
-                uid_validity,
-                last_seen_uid
-            );
 
             if mailbox.exists == 0 {
-                info!(context, "Folder \"{}\" is empty.", folder.as_ref());
+                info!(context, "Folder \"{}\" is empty.", folder);
 
                 // set lastseenuid=0 for empty folders.
                 // id we do not do this here, we'll miss the first message
                 // as we will get in here again and fetch from lastseenuid+1 then
 
                 self.set_config_last_seen_uid(context, &folder, new_uid_validity, 0);
-                return Ok(false);
+                return Ok((new_uid_validity, 0));
             }
 
-            let list = if let Some(ref mut session) = &mut *self.session.lock().await {
-                // `FETCH <message sequence number> (UID)`
-                let set = format!("{}", mailbox.exists);
-                match session.fetch(set, PREFETCH_FLAGS).await {
-                    Ok(list) => list,
-                    Err(err) => {
-                        bail!("fetch failed: {}", err);
+            // uid_validity has changed or is being set the first time.
+            // find the last seen uid within the new uid_validity scope.
+            let new_last_seen_uid = match mailbox.uid_next {
+                Some(uid_next) => {
+                    uid_next - 1 // XXX could uid_next be 0?
+                }
+                None => {
+                    warn!(
+                        context,
+                        "IMAP folder has no uid_next, fall back to fetching"
+                    );
+                    if let Some(ref mut session) = &mut *self.session.lock().await {
+                        // note that we use fetch by sequence number
+                        // and thus we only need to get exactly the
+                        // last-index message.
+                        let set = format!("{}", mailbox.exists);
+                        match session.fetch(set, JUST_UID).await {
+                            Ok(list) => list[0].uid.unwrap_or_default(),
+                            Err(err) => {
+                                return Err(Error::FetchFailed(err));
+                            }
+                        }
+                    } else {
+                        return Err(Error::NoConnection);
                     }
                 }
-            } else {
-                return Err(Error::ImapNoConnection);
             };
 
-            last_seen_uid = list[0].uid.unwrap_or_else(|| 0);
-
-            // if the UIDVALIDITY has _changed_, decrease lastseenuid by one to avoid gaps (well add 1 below
-            if uid_validity > 0 && last_seen_uid > 1 {
-                last_seen_uid -= 1;
-            }
-
-            uid_validity = new_uid_validity;
-            self.set_config_last_seen_uid(context, &folder, uid_validity, last_seen_uid);
+            self.set_config_last_seen_uid(context, &folder, new_uid_validity, new_last_seen_uid);
             info!(
                 context,
-                "lastseenuid initialized to {} for {}@{}",
-                last_seen_uid,
-                folder.as_ref(),
+                "uid/validity change: new {}/{} current {}/{}",
+                new_last_seen_uid,
+                new_uid_validity,
                 uid_validity,
+                last_seen_uid
             );
-        }
+            Ok((new_uid_validity, new_last_seen_uid))
+        })
+    }
+
+    async fn fetch_from_single_folder<S: AsRef<str>>(
+        &self,
+        context: &Context,
+        folder: S,
+    ) -> Result<bool> {
+        let (uid_validity, last_seen_uid) =
+            self.select_with_uidvalidity(context, folder.as_ref())?;
 
         let mut read_cnt = 0;
-        let mut read_errors = 0;
-        let mut new_last_seen_uid = 0;
 
-        let list = if let Some(ref mut session) = &mut *self.session.lock().await {
+        let mut list = if let Some(ref mut session) = &mut *self.session.lock().await {
             // fetch messages with larger UID than the last one seen
             // (`UID FETCH lastseenuid+1:*)`, see RFC 4549
             let set = format!("{}:*", last_seen_uid + 1);
             match session.uid_fetch(set, PREFETCH_FLAGS).await {
                 Ok(list) => list,
                 Err(err) => {
-                    bail!("uid_fetch failed: {}", err);
+                    return Err(Error::FetchFailed(err));
                 }
             }
         } else {
-            return Err(Error::ImapNoConnection);
+            return Err(Error::NoConnection);
         };
 
-        // go through all mails in folder (this is typically _fast_ as we already have the whole list)
+        // prefetch info from all unfetched mails
+        let mut new_last_seen_uid = last_seen_uid;
+        let mut read_errors = 0;
+
+        list.sort_unstable_by_key(|msg| msg.uid.unwrap_or_default());
+
         for msg in &list {
-            let cur_uid = msg.uid.unwrap_or_else(|| 0);
-            if cur_uid > last_seen_uid {
-                read_cnt += 1;
+            let cur_uid = msg.uid.unwrap_or_default();
+            if cur_uid <= last_seen_uid {
+                warn!(
+                    context,
+                    "unexpected uid {}, last seen was {}", cur_uid, last_seen_uid
+                );
+                continue;
+            }
+            read_cnt += 1;
 
-                let message_id = prefetch_get_message_id(msg).unwrap_or_default();
+            let message_id = prefetch_get_message_id(msg).unwrap_or_default();
 
-                if !precheck_imf(context, &message_id, folder.as_ref(), cur_uid) {
-                    // check passed, go fetch the rest
-                    if self.fetch_single_msg(context, &folder, cur_uid).await == 0 {
-                        info!(
-                            context,
-                            "Read error for message {} from \"{}\", trying over later.",
-                            message_id,
-                            folder.as_ref()
-                        );
-
-                        read_errors += 1;
-                    }
-                } else {
-                    // check failed
+            if !precheck_imf(context, &message_id, folder.as_ref(), cur_uid) {
+                // check passed, go fetch the rest
+                if self.fetch_single_msg(context, &folder, cur_uid).await == 0 {
                     info!(
                         context,
-                        "Skipping message {} from \"{}\" by precheck.",
+                        "Read error for message {} from \"{}\", trying over later.",
                         message_id,
-                        folder.as_ref(),
+                        folder.as_ref()
                     );
+                    read_errors += 1;
                 }
-                if cur_uid > new_last_seen_uid {
-                    new_last_seen_uid = cur_uid
-                }
+            } else {
+                // we know the message-id already or don't want the message otherwise.
+                info!(
+                    context,
+                    "Skipping message {} from \"{}\" by precheck.",
+                    message_id,
+                    folder.as_ref(),
+                );
+            }
+            if read_errors == 0 {
+                new_last_seen_uid = cur_uid;
             }
         }
 
-        if 0 == read_errors && new_last_seen_uid > 0 {
-            // TODO: it might be better to increase the lastseenuid also on partial errors.
-            // however, this requires to sort the list before going through it above.
+        if new_last_seen_uid > last_seen_uid {
             self.set_config_last_seen_uid(context, &folder, uid_validity, new_last_seen_uid);
         }
 
@@ -745,9 +825,7 @@ impl Imap {
 
             if !is_deleted && msg.body().is_some() {
                 let body = msg.body().unwrap_or_default();
-                unsafe {
-                    dc_receive_imf(context, &body, folder.as_ref(), server_uid, flags as u32);
-                }
+                dc_receive_imf(context, &body, folder.as_ref(), server_uid, flags as u32);
             }
         }
 
@@ -757,18 +835,12 @@ impl Imap {
     pub fn idle(&self, context: &Context, watch_folder: Option<String>) -> Result<()> {
         task::block_on(async move {
             if !self.config.read().await.can_idle {
-                return Err(Error::ImapMissesIdle);
+                return Err(Error::IdleAbilityMissing);
             }
 
             self.setup_handle_if_needed(context)?;
 
-            match self.select_folder(context, watch_folder.clone()).await {
-                ImapActionResult::Success | ImapActionResult::AlreadyDone => {}
-
-                ImapActionResult::Failed | ImapActionResult::RetryLater => {
-                    return Err(Error::ImapSelectFailed(format!("{:?}", watch_folder)));
-                }
-            }
+            self.select_folder(context, watch_folder.clone()).await?;
 
             let session = self.session.lock().await.take();
             let timeout = Duration::from_secs(23 * 60);
@@ -778,7 +850,7 @@ impl Imap {
                     // typically also need to change the Insecure branch.
                     IdleHandle::Secure(mut handle) => {
                         if let Err(err) = handle.init().await {
-                            return Err(Error::ImapIdleProtocolFailed(err.to_string()));
+                            return Err(Error::IdleProtocolFailed(err));
                         }
 
                         let (idle_wait, interrupt) = handle.wait_with_timeout(timeout);
@@ -816,13 +888,13 @@ impl Imap {
                                 // means that we waited long (with idle_wait)
                                 // but the network went away/changed
                                 self.trigger_reconnect();
-                                return Err(Error::ImapIdleProtocolFailed(err.to_string()));
+                                return Err(Error::IdleProtocolFailed(err));
                             }
                         }
                     }
                     IdleHandle::Insecure(mut handle) => {
                         if let Err(err) = handle.init().await {
-                            return Err(Error::ImapIdleProtocolFailed(err.to_string()));
+                            return Err(Error::IdleProtocolFailed(err));
                         }
 
                         let (idle_wait, interrupt) = handle.wait_with_timeout(timeout);
@@ -860,7 +932,7 @@ impl Imap {
                                 // means that we waited long (with idle_wait)
                                 // but the network went away/changed
                                 self.trigger_reconnect();
-                                return Err(Error::ImapIdleProtocolFailed(err.to_string()));
+                                return Err(Error::IdleProtocolFailed(err));
                             }
                         }
                     }
@@ -941,7 +1013,7 @@ impl Imap {
         })
     }
 
-    pub fn interrupt_idle(&self) {
+    pub fn interrupt_idle(&self, context: &Context) {
         task::block_on(async move {
             let mut interrupt: Option<stop_token::StopSource> = self.interrupt.lock().await.take();
             if interrupt.is_none() {
@@ -953,7 +1025,12 @@ impl Imap {
             }
             // let's manually drop the StopSource
             if interrupt.is_some() {
-                eprintln!("low-level: dropping stop-source to interrupt idle");
+                // the imap thread provided us a stop token but might
+                // not have entered idle_wait yet, give it some time
+                // for that to happen. XXX handle this without extra wait
+                // https://github.com/deltachat/deltachat-core-rust/issues/925
+                std::thread::sleep(Duration::from_millis(200));
+                info!(context, "low-level: dropping stop-source to interrupt idle");
                 std::mem::drop(interrupt)
             }
         });
@@ -1097,14 +1174,22 @@ impl Imap {
                 }
             }
             match self.select_folder(context, Some(&folder)).await {
-                ImapActionResult::Success | ImapActionResult::AlreadyDone => None,
-                res => {
-                    warn!(
-                        context,
-                        "Cannot select folder {} for preparing IMAP operation", folder
-                    );
-
-                    Some(res)
+                Ok(()) => None,
+                Err(Error::ConnectionLost) => {
+                    warn!(context, "Lost imap connection");
+                    Some(ImapActionResult::RetryLater)
+                }
+                Err(Error::NoSession) => {
+                    warn!(context, "no imap session");
+                    Some(ImapActionResult::Failed)
+                }
+                Err(Error::BadFolderName(folder_name)) => {
+                    warn!(context, "invalid folder name: {:?}", folder_name);
+                    Some(ImapActionResult::Failed)
+                }
+                Err(err) => {
+                    warn!(context, "failed to select folder: {:?}: {:?}", folder, err);
+                    Some(ImapActionResult::RetryLater)
                 }
             }
         })
@@ -1206,19 +1291,30 @@ impl Imap {
         })
     }
 
-    pub fn configure_folders(&self, context: &Context, create_mvbox: bool) {
+    pub fn ensure_configured_folders(&self, context: &Context, create_mvbox: bool) -> Result<()> {
+        let folders_configured = context
+            .sql
+            .get_raw_config_int(context, "folders_configured");
+        if folders_configured.unwrap_or_default() >= 3 {
+            // the "3" here we increase if we have future updates to
+            // to folder configuration
+            return Ok(());
+        }
+
         task::block_on(async move {
             if !self.is_connected().await {
-                return;
+                return Err(Error::NoConnection);
             }
 
             info!(context, "Configuring IMAP-folders.");
 
             if let Some(ref mut session) = &mut *self.session.lock().await {
-                let folders = self
-                    .list_folders(session, context)
-                    .await
-                    .expect("no folders found");
+                let folders = match self.list_folders(session, context).await {
+                    Some(f) => f,
+                    None => {
+                        return Err(Error::Other("list_folders failed".to_string()));
+                    }
+                };
 
                 let sentbox_folder =
                     folders
@@ -1249,7 +1345,7 @@ impl Imap {
                         Err(err) => {
                             warn!(
                                 context,
-                                "Cannot create MVBOX-folder, using trying INBOX subfolder. ({})",
+                                "Cannot create MVBOX-folder, trying to create INBOX subfolder. ({})",
                                 err
                             );
 
@@ -1271,35 +1367,34 @@ impl Imap {
                     // that may be used by other MUAs to list folders.
                     // for the LIST command, the folder is always visible.
                     if let Some(ref mvbox) = mvbox_folder {
-                        // TODO: better error handling
-                        session.subscribe(mvbox).await.expect("failed to subscribe");
+                        if let Err(err) = session.subscribe(mvbox).await {
+                            warn!(context, "could not subscribe to {:?}: {:?}", mvbox, err);
+                        }
                     }
                 }
                 context
                     .sql
-                    .set_raw_config(context, "configured_inbox_folder", Some("INBOX"))
-                    .ok();
+                    .set_raw_config(context, "configured_inbox_folder", Some("INBOX"))?;
                 if let Some(ref mvbox_folder) = mvbox_folder {
-                    context
-                        .sql
-                        .set_raw_config(context, "configured_mvbox_folder", Some(mvbox_folder))
-                        .ok();
+                    context.sql.set_raw_config(
+                        context,
+                        "configured_mvbox_folder",
+                        Some(mvbox_folder),
+                    )?;
                 }
                 if let Some(ref sentbox_folder) = sentbox_folder {
-                    context
-                        .sql
-                        .set_raw_config(
-                            context,
-                            "configured_sentbox_folder",
-                            Some(sentbox_folder.name()),
-                        )
-                        .ok();
+                    context.sql.set_raw_config(
+                        context,
+                        "configured_sentbox_folder",
+                        Some(sentbox_folder.name()),
+                    )?;
                 }
                 context
                     .sql
-                    .set_raw_config_int(context, "folders_configured", 3)
-                    .ok();
+                    .set_raw_config_int(context, "folders_configured", 3)?;
             }
+            info!(context, "FINISHED configuring IMAP-folders.");
+            Ok(())
         })
     }
 
@@ -1330,33 +1425,35 @@ impl Imap {
             info!(context, "emptying folder {}", folder);
 
             if folder.is_empty() {
-                warn!(context, "cannot perform empty, folder not set");
+                error!(context, "cannot perform empty, folder not set");
                 return;
             }
-            match self.select_folder(context, Some(&folder)).await {
-                ImapActionResult::Success | ImapActionResult::AlreadyDone => {
-                    if !self
-                        .add_flag_finalized_with_set(context, SELECT_ALL, "\\Deleted")
-                        .await
-                    {
-                        warn!(context, "Cannot empty folder {}", folder);
-                    } else {
-                        // we now trigger expunge to actually delete messages
-                        self.config.write().await.selected_folder_needs_expunge = true;
-                        if self.select_folder::<String>(context, None).await
-                            == ImapActionResult::Success
-                        {
-                            emit_event!(context, Event::ImapFolderEmptied(folder.to_string()));
-                        } else {
-                            warn!(
-                                context,
-                                "could not perform expunge on empty-marked folder {}", folder
-                            );
-                        }
-                    }
+            if let Err(err) = self.select_folder(context, Some(&folder)).await {
+                // we want to report all error to the user
+                // (no retry should be attempted)
+                error!(
+                    context,
+                    "Could not select {} for expunging: {:?}", folder, err
+                );
+                return;
+            }
+
+            if !self
+                .add_flag_finalized_with_set(context, SELECT_ALL, "\\Deleted")
+                .await
+            {
+                error!(context, "Cannot mark messages for deletion {}", folder);
+                return;
+            }
+
+            // we now trigger expunge to actually delete messages
+            self.config.write().await.selected_folder_needs_expunge = true;
+            match self.select_folder::<String>(context, None).await {
+                Ok(()) => {
+                    emit_event!(context, Event::ImapFolderEmptied(folder.to_string()));
                 }
-                ImapActionResult::Failed | ImapActionResult::RetryLater => {
-                    warn!(context, "could not select folder {}", folder);
+                Err(err) => {
+                    error!(context, "expunge failed {}: {:?}", folder, err);
                 }
             }
         });
@@ -1435,11 +1532,16 @@ fn precheck_imf(context: &Context, rfc724_mid: &str, server_folder: &str, server
 }
 
 fn prefetch_get_message_id(prefetch_msg: &Fetch) -> Result<String> {
-    ensure!(
-        prefetch_msg.envelope().is_some(),
-        "Fetched message has no envelope"
-    );
+    if prefetch_msg.envelope().is_none() {
+        return Err(Error::Other(
+            "prefectch: message has no envelope".to_string(),
+        ));
+    }
+
     let message_id = prefetch_msg.envelope().unwrap().message_id;
-    ensure!(message_id.is_some(), "No message ID found");
-    wrapmime::parse_message_id(&message_id.unwrap())
+    if message_id.is_none() {
+        return Err(Error::Other("prefetch: No message ID found".to_string()));
+    }
+
+    wrapmime::parse_message_id(&message_id.unwrap()).map_err(Into::into)
 }

src/imex.rs

@@ -12,7 +12,6 @@ use crate::config::Config;
 use crate::configure::*;
 use crate::constants::*;
 use crate::context::Context;
-use crate::dc_mimeparser::SystemMessage;
 use crate::dc_tools::*;
 use crate::e2ee;
 use crate::error::*;
@@ -20,6 +19,7 @@ use crate::events::Event;
 use crate::job::*;
 use crate::key::*;
 use crate::message::{Message, MsgId};
+use crate::mimeparser::SystemMessage;
 use crate::param::*;
 use crate::pgp;
 use crate::sql::{self, Sql};
@@ -462,7 +462,9 @@ fn import_backup(context: &Context, backup_to_import: impl AsRef<Path>) -> Resul
         |files| {
             for (processed_files_cnt, file) in files.enumerate() {
                 let (file_name, file_blob) = file?;
-                ensure!(!context.shall_stop_ongoing(), "received stop signal");
+                if context.shall_stop_ongoing() {
+                    return Ok(false);
+                }
                 let mut permille = processed_files_cnt * 1000 / total_files_cnt;
                 if permille < 10 {
                     permille = 10
@@ -476,25 +478,25 @@ fn import_backup(context: &Context, backup_to_import: impl AsRef<Path>) -> Resul
                 }
 
                 let path_filename = context.get_blobdir().join(file_name);
-                if dc_write_file(context, &path_filename, &file_blob) {
-                    continue;
-                }
-                bail!(
-                    "Storage full? Cannot write file {} with {} bytes.",
-                    path_filename.display(),
-                    file_blob.len(),
-                );
+                dc_write_file(context, &path_filename, &file_blob)?;
             }
-            Ok(())
+            Ok(true)
         },
     );
 
-    res.and_then(|_| {
-        // only delete backup_blobs if all files were successfully extracted
-        sql::execute(context, &context.sql, "DROP TABLE backup_blobs;", params![])?;
-        sql::try_execute(context, &context.sql, "VACUUM;").ok();
-        Ok(())
-    })
+    match res {
+        Ok(all_files_extracted) => {
+            if all_files_extracted {
+                // only delete backup_blobs if all files were successfully extracted
+                sql::execute(context, &context.sql, "DROP TABLE backup_blobs;", params![])?;
+                sql::try_execute(context, &context.sql, "VACUUM;").ok();
+                Ok(())
+            } else {
+                bail!("received stop signal");
+            }
+        }
+        Err(err) => Err(err.into()),
+    }
 }
 
 /*******************************************************************************
@@ -552,7 +554,7 @@ fn export_backup(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
     };
     dest_sql.close(context);
 
-    res
+    Ok(res?)
 }
 
 fn add_files_to_export(context: &Context, sql: &Sql) -> Result<()> {
@@ -575,16 +577,15 @@ fn add_files_to_export(context: &Context, sql: &Sql) -> Result<()> {
     info!(context, "EXPORT: total_files_cnt={}", total_files_cnt);
     // scan directory, pass 2: copy files
     let dir_handle = std::fs::read_dir(&dir)?;
-    sql.prepare(
+    let exported_all_files = sql.prepare(
         "INSERT INTO backup_blobs (file_name, file_content) VALUES (?, ?);",
         |mut stmt, _| {
             let mut processed_files_cnt = 0;
             for entry in dir_handle {
                 let entry = entry?;
-                ensure!(
-                    !context.shall_stop_ongoing(),
-                    "canceled during export-files"
-                );
+                if context.shall_stop_ongoing() {
+                    return Ok(false);
+                }
                 processed_files_cnt += 1;
                 let permille = max(min(processed_files_cnt * 1000 / total_files_cnt, 990), 10);
                 context.call_cb(Event::ImexProgress(permille));
@@ -604,9 +605,10 @@ fn add_files_to_export(context: &Context, sql: &Sql) -> Result<()> {
                     stmt.execute(params![name, buf])?;
                 }
             }
-            Ok(())
+            Ok(true)
         },
     )?;
+    ensure!(exported_all_files, "canceled during export-files");
     Ok(())
 }
 
@@ -686,14 +688,14 @@ fn export_self_keys(context: &Context, dir: impl AsRef<Path>) -> Result<()> {
                 let (id, public_key, private_key, is_default) = key_pair?;
                 let id = Some(id).filter(|_| is_default != 0);
                 if let Some(key) = public_key {
-                    if !export_key_to_asc_file(context, &dir, id, &key) {
+                    if export_key_to_asc_file(context, &dir, id, &key).is_err() {
                         export_errors += 1;
                     }
                 } else {
                     export_errors += 1;
                 }
                 if let Some(key) = private_key {
-                    if !export_key_to_asc_file(context, &dir, id, &key) {
+                    if export_key_to_asc_file(context, &dir, id, &key).is_err() {
                         export_errors += 1;
                     }
                 } else {
@@ -717,8 +719,7 @@ fn export_key_to_asc_file(
     dir: impl AsRef<Path>,
     id: Option<i64>,
     key: &Key,
-) -> bool {
-    let mut success = false;
+) -> std::io::Result<()> {
     let file_name = {
         let kind = if key.is_public() { "public" } else { "private" };
         let id = id.map_or("default".into(), |i| i.to_string());
@@ -728,14 +729,13 @@ fn export_key_to_asc_file(
     info!(context, "Exporting key {}", file_name.display());
     dc_delete_file(context, &file_name);
 
-    if !key.write_asc_to_file(&file_name, context) {
+    let res = key.write_asc_to_file(&file_name, context);
+    if res.is_err() {
         error!(context, "Cannot write key to {}", file_name.display());
     } else {
         context.call_cb(Event::ImexFileWritten(file_name));
-        success = true;
     }
-
-    success
+    res
 }
 
 #[cfg(test)]
@@ -799,7 +799,7 @@ mod tests {
         let base64 = include_str!("../test-data/key/public.asc");
         let key = Key::from_base64(base64, KeyType::Public).unwrap();
         let blobdir = "$BLOBDIR";
-        assert!(export_key_to_asc_file(&context.ctx, blobdir, None, &key));
+        assert!(export_key_to_asc_file(&context.ctx, blobdir, None, &key).is_ok());
         let blobdir = context.ctx.get_blobdir().to_str().unwrap();
         let filename = format!("{}/public-key-default.asc", blobdir);
         let bytes = std::fs::read(&filename).unwrap();

src/job.rs

@@ -18,7 +18,7 @@ use crate::location;
 use crate::login_param::LoginParam;
 use crate::message::MsgId;
 use crate::message::{self, Message, MessageState};
-use crate::mimefactory::{vec_contains_lowercase, Loaded, MimeFactory};
+use crate::mimefactory::{vec_contains_lowercase, MimeFactory, RenderedEmail};
 use crate::param::*;
 use crate::sql;
 
@@ -184,11 +184,22 @@ impl Job {
                     // otherwise might send it twice.
                     let mut smtp = context.smtp.lock().unwrap();
                     match smtp.send(context, recipients_list, body, self.job_id) {
-                        Err(err) => {
+                        Err(crate::smtp::send::Error::SendError(err)) => {
+                            // Remote error, retry later.
                             smtp.disconnect();
-                            warn!(context, "smtp failed: {}", err);
+                            info!(context, "SMTP failed to send: {}", err);
                             self.try_again_later(TryAgain::AtOnce, Some(err.to_string()));
                         }
+                        Err(crate::smtp::send::Error::EnvelopeError(err)) => {
+                            // Local error, job is invalid, do not retry.
+                            smtp.disconnect();
+                            warn!(context, "SMTP job is invalid: {}", err);
+                        }
+                        Err(crate::smtp::send::Error::NoTransport) => {
+                            // Should never happen.
+                            // It does not even make sense to disconnect here.
+                            error!(context, "SMTP job failed because SMTP has no transport");
+                        }
                         Ok(()) => {
                             // smtp success, update db ASAP, then delete smtp file
                             if 0 != self.foreign_id {
@@ -216,13 +227,10 @@ impl Job {
         let imap_inbox = &context.inbox_thread.read().unwrap().imap;
 
         if let Ok(msg) = Message::load_from_db(context, MsgId::new(self.foreign_id)) {
-            if context
-                .sql
-                .get_raw_config_int(context, "folders_configured")
-                .unwrap_or_default()
-                < 3
-            {
-                imap_inbox.configure_folders(context, true);
+            if let Err(err) = imap_inbox.ensure_configured_folders(context, true) {
+                self.try_again_later(TryAgain::StandardDelay, None);
+                warn!(context, "could not configure folders: {:?}", err);
+                return;
             }
             let dest_folder = context
                 .sql
@@ -343,13 +351,10 @@ impl Job {
             return;
         }
         if 0 != self.param.get_int(Param::AlsoMove).unwrap_or_default() {
-            if context
-                .sql
-                .get_raw_config_int(context, "folders_configured")
-                .unwrap_or_default()
-                < 3
-            {
-                imap_inbox.configure_folders(context, true);
+            if let Err(err) = imap_inbox.ensure_configured_folders(context, true) {
+                self.try_again_later(TryAgain::StandardDelay, None);
+                warn!(context, "configuring folders failed: {:?}", err);
+                return;
             }
             let dest_folder = context
                 .sql
@@ -599,42 +604,19 @@ fn set_delivered(context: &Context, msg_id: MsgId) {
 /* special case for DC_JOB_SEND_MSG_TO_SMTP */
 #[allow(non_snake_case)]
 pub fn job_send_msg(context: &Context, msg_id: MsgId) -> Result<(), Error> {
-    let mut mimefactory = MimeFactory::load_msg(context, msg_id)?;
-
-    if chat::msgtype_has_file(mimefactory.msg.type_0) {
-        let file_param = mimefactory.msg.param.get_path(Param::File, context)?;
-        if let Some(pathNfilename) = file_param {
-            if (mimefactory.msg.type_0 == Viewtype::Image
-                || mimefactory.msg.type_0 == Viewtype::Gif)
-                && !mimefactory.msg.param.exists(Param::Width)
-            {
-                mimefactory.msg.param.set_int(Param::Width, 0);
-                mimefactory.msg.param.set_int(Param::Height, 0);
-
-                if let Ok(buf) = dc_read_file(context, pathNfilename) {
-                    if let Ok((width, height)) = dc_get_filemeta(&buf) {
-                        mimefactory.msg.param.set_int(Param::Width, width as i32);
-                        mimefactory.msg.param.set_int(Param::Height, height as i32);
-                    }
-                }
-                mimefactory.msg.save_param_to_disk(context);
-            }
-        }
-    }
+    let mut msg = Message::load_from_db(context, msg_id)?;
+    msg.try_calc_and_set_dimensions(context).ok();
 
     /* create message */
-    if let Err(msg) = unsafe { mimefactory.render() } {
-        let e = msg.to_string();
-        message::set_msg_failed(context, msg_id, Some(e));
-        return Err(msg);
-    }
-    if 0 != mimefactory
-        .msg
-        .param
-        .get_int(Param::GuaranteeE2ee)
-        .unwrap_or_default()
-        && !mimefactory.out_encrypted
-    {
+    let needs_encryption = msg.param.get_int(Param::GuaranteeE2ee).unwrap_or_default();
+
+    let mimefactory = MimeFactory::from_msg(context, &msg)?;
+    let mut rendered_msg = mimefactory.render().map_err(|err| {
+        message::set_msg_failed(context, msg_id, Some(err.to_string()));
+        err
+    })?;
+
+    if 0 != needs_encryption && !rendered_msg.is_encrypted {
         /* unrecoverable */
         message::set_msg_failed(
             context,
@@ -644,19 +626,17 @@ pub fn job_send_msg(context: &Context, msg_id: MsgId) -> Result<(), Error> {
         bail!(
             "e2e encryption unavailable {} - {:?}",
             msg_id,
-            mimefactory.msg.param.get_int(Param::GuaranteeE2ee),
+            needs_encryption
         );
     }
+
     if context.get_config_bool(Config::BccSelf)
-        && !vec_contains_lowercase(&mimefactory.recipients_addr, &mimefactory.from_addr)
+        && !vec_contains_lowercase(&rendered_msg.recipients, &rendered_msg.from)
     {
-        mimefactory.recipients_names.push("".to_string());
-        mimefactory
-            .recipients_addr
-            .push(mimefactory.from_addr.to_string());
+        rendered_msg.recipients.push(rendered_msg.from.clone());
     }
 
-    if mimefactory.recipients_addr.is_empty() {
+    if rendered_msg.recipients.is_empty() {
         // may happen eg. for groups with only SELF and bcc_self disabled
         info!(
             context,
@@ -666,36 +646,27 @@ pub fn job_send_msg(context: &Context, msg_id: MsgId) -> Result<(), Error> {
         return Ok(());
     }
 
-    if mimefactory.out_gossiped {
-        chat::set_gossiped_timestamp(context, mimefactory.msg.chat_id, time());
+    if rendered_msg.is_gossiped {
+        chat::set_gossiped_timestamp(context, msg.chat_id, time());
     }
-    if 0 != mimefactory.out_last_added_location_id {
-        if let Err(err) = location::set_kml_sent_timestamp(context, mimefactory.msg.chat_id, time())
-        {
+    if 0 != rendered_msg.last_added_location_id {
+        if let Err(err) = location::set_kml_sent_timestamp(context, msg.chat_id, time()) {
             error!(context, "Failed to set kml sent_timestamp: {:?}", err);
         }
-        if !mimefactory.msg.hidden {
-            if let Err(err) = location::set_msg_location_id(
-                context,
-                mimefactory.msg.id,
-                mimefactory.out_last_added_location_id,
-            ) {
+        if !msg.hidden {
+            if let Err(err) =
+                location::set_msg_location_id(context, msg.id, rendered_msg.last_added_location_id)
+            {
                 error!(context, "Failed to set msg_location_id: {:?}", err);
             }
         }
     }
-    if mimefactory.out_encrypted
-        && mimefactory
-            .msg
-            .param
-            .get_int(Param::GuaranteeE2ee)
-            .unwrap_or_default()
-            == 0
-    {
-        mimefactory.msg.param.set_int(Param::GuaranteeE2ee, 1);
-        mimefactory.msg.save_param_to_disk(context);
+    if rendered_msg.is_encrypted && needs_encryption == 0 {
+        msg.param.set_int(Param::GuaranteeE2ee, 1);
+        msg.save_param_to_disk(context);
     }
-    add_smtp_job(context, Action::SendMsgToSmtp, &mut mimefactory)?;
+
+    add_smtp_job(context, Action::SendMsgToSmtp, &rendered_msg)?;
 
     Ok(())
 }
@@ -881,38 +852,40 @@ fn suspend_smtp_thread(context: &Context, suspend: bool) {
 }
 
 fn send_mdn(context: &Context, msg_id: MsgId) -> Result<(), Error> {
-    let mut mimefactory = MimeFactory::load_mdn(context, msg_id)?;
-    unsafe { mimefactory.render()? };
-    add_smtp_job(context, Action::SendMdn, &mut mimefactory)?;
+    let msg = Message::load_from_db(context, msg_id)?;
+    let mimefactory = MimeFactory::from_mdn(context, &msg)?;
+    let rendered_msg = mimefactory.render()?;
+
+    add_smtp_job(context, Action::SendMdn, &rendered_msg)?;
 
     Ok(())
 }
 
 #[allow(non_snake_case)]
-fn add_smtp_job(context: &Context, action: Action, mimefactory: &MimeFactory) -> Result<(), Error> {
+fn add_smtp_job(
+    context: &Context,
+    action: Action,
+    rendered_msg: &RenderedEmail,
+) -> Result<(), Error> {
     ensure!(
-        !mimefactory.recipients_addr.is_empty(),
+        !rendered_msg.recipients.is_empty(),
         "no recipients for smtp job set"
     );
     let mut param = Params::new();
-    let bytes = unsafe {
-        std::slice::from_raw_parts(
-            (*mimefactory.out).str_0 as *const u8,
-            (*mimefactory.out).len,
-        )
-    };
-    let blob = BlobObject::create(context, &mimefactory.rfc724_mid, bytes)?;
-    let recipients = mimefactory.recipients_addr.join("\x1e");
+    let bytes = &rendered_msg.message;
+    let blob = BlobObject::create(context, &rendered_msg.rfc724_mid, bytes)?;
+
+    let recipients = rendered_msg.recipients.join("\x1e");
     param.set(Param::File, blob.as_name());
     param.set(Param::Recipients, &recipients);
+
     job_add(
         context,
         action,
-        (if mimefactory.loaded == Loaded::Message {
-            mimefactory.msg.id.to_u32() as i32
-        } else {
-            0
-        }) as libc::c_int,
+        rendered_msg
+            .foreign_id
+            .map(|v| v.to_u32() as i32)
+            .unwrap_or_default(),
         param,
         0,
     );
@@ -923,7 +896,7 @@ fn add_smtp_job(context: &Context, action: Action, mimefactory: &MimeFactory) ->
 pub fn job_add(
     context: &Context,
     action: Action,
-    foreign_id: libc::c_int,
+    foreign_id: i32,
     param: Params,
     delay_seconds: i64,
 ) {

src/job_thread.rs

@@ -63,7 +63,7 @@ impl JobThread {
 
         info!(context, "Interrupting {}-IDLE...", self.name);
 
-        self.imap.interrupt_idle();
+        self.imap.interrupt_idle(context);
 
         let &(ref lock, ref cvar) = &*self.state.clone();
         let mut state = lock.lock().unwrap();
@@ -104,7 +104,7 @@ impl JobThread {
                 if let Some(watch_folder) = self.get_watch_folder(context) {
                     let start = std::time::Instant::now();
                     info!(context, "{} started...", prefix);
-                    let res = self.imap.fetch(context, &watch_folder);
+                    let res = self.imap.fetch(context, &watch_folder).map_err(Into::into);
                     let elapsed = start.elapsed().as_millis();
                     info!(context, "{} done in {:.3} ms.", prefix, elapsed);
 
@@ -113,7 +113,7 @@ impl JobThread {
                     Err(Error::WatchFolderNotFound("not-set".to_string()))
                 }
             }
-            Err(err) => Err(err),
+            Err(err) => Err(crate::error::Error::Message(err.to_string())),
         }
     }
 
@@ -176,7 +176,7 @@ impl JobThread {
                 info!(context, "{} ended...", prefix);
                 match res {
                     Ok(()) => false,
-                    Err(Error::ImapMissesIdle) => true, // we have to do fake_idle
+                    Err(crate::imap::Error::IdleAbilityMissing) => true, // we have to do fake_idle
                     Err(err) => {
                         warn!(context, "{} failed: {} -> reconnecting", prefix, err);
                         // something is borked, let's start afresh on the next occassion

src/key.rs

@@ -217,15 +217,18 @@ impl Key {
             .expect("failed to serialize key")
     }
 
-    pub fn write_asc_to_file(&self, file: impl AsRef<Path>, context: &Context) -> bool {
+    pub fn write_asc_to_file(
+        &self,
+        file: impl AsRef<Path>,
+        context: &Context,
+    ) -> std::io::Result<()> {
         let file_content = self.to_asc(None).into_bytes();
 
-        if dc_write_file(context, &file, &file_content) {
-            true
-        } else {
+        let res = dc_write_file(context, &file, &file_content);
+        if res.is_err() {
             error!(context, "Cannot write key to {}", file.as_ref().display());
-            false
         }
+        res
     }
 
     pub fn fingerprint(&self) -> String {

src/lib.rs

@@ -17,12 +17,10 @@ extern crate strum;
 #[macro_use]
 extern crate strum_macros;
 #[macro_use]
-extern crate jetscii;
-#[macro_use]
 extern crate debug_stub_derive;
 
 #[macro_use]
-pub mod log;
+mod log;
 #[macro_use]
 pub mod error;
 
@@ -51,6 +49,7 @@ mod login_param;
 pub mod lot;
 pub mod message;
 mod mimefactory;
+pub mod mimeparser;
 pub mod oauth2;
 mod param;
 pub mod peerstate;
@@ -63,10 +62,9 @@ pub mod stock;
 mod token;
 #[macro_use]
 mod wrapmime;
+mod dehtml;
 
 pub mod dc_array;
-mod dc_dehtml;
-pub mod dc_mimeparser;
 pub mod dc_receive_imf;
 mod dc_simplify;
 mod dc_strencode;

src/location.rs

@@ -8,12 +8,12 @@ use crate::chat;
 use crate::config::Config;
 use crate::constants::*;
 use crate::context::*;
-use crate::dc_mimeparser::SystemMessage;
 use crate::dc_tools::*;
 use crate::error::Error;
 use crate::events::Event;
 use crate::job::*;
 use crate::message::{Message, MsgId};
+use crate::mimeparser::SystemMessage;
 use crate::param::*;
 use crate::sql;
 use crate::stock::StockMessage;
@@ -229,7 +229,7 @@ pub fn send_locations_to_chat(context: &Context, chat_id: u32, seconds: i64) {
                 job_add(
                     context,
                     Action::MaybeSendLocationsEnded,
-                    chat_id as libc::c_int,
+                    chat_id as i32,
                     Params::new(),
                     seconds + 1,
                 );
@@ -495,46 +495,50 @@ pub fn save(
     independent: bool,
 ) -> Result<u32, Error> {
     ensure!(chat_id > DC_CHAT_ID_LAST_SPECIAL, "Invalid chat id");
-    context.sql.prepare2(
-        "SELECT id FROM locations WHERE timestamp=? AND from_id=?",
-        "INSERT INTO locations\
-         (timestamp, from_id, chat_id, latitude, longitude, accuracy, independent) \
-         VALUES (?,?,?,?,?,?,?);",
-        |mut stmt_test, mut stmt_insert, conn| {
-            let mut newest_timestamp = 0;
-            let mut newest_location_id = 0;
+    context
+        .sql
+        .prepare2(
+            "SELECT id FROM locations WHERE timestamp=? AND from_id=?",
+            "INSERT INTO locations\
+             (timestamp, from_id, chat_id, latitude, longitude, accuracy, independent) \
+             VALUES (?,?,?,?,?,?,?);",
+            |mut stmt_test, mut stmt_insert, conn| {
+                let mut newest_timestamp = 0;
+                let mut newest_location_id = 0;
 
-            for location in locations {
-                let exists = stmt_test.exists(params![location.timestamp, contact_id as i32])?;
+                for location in locations {
+                    let exists =
+                        stmt_test.exists(params![location.timestamp, contact_id as i32])?;
 
-                if independent || !exists {
-                    stmt_insert.execute(params![
-                        location.timestamp,
-                        contact_id as i32,
-                        chat_id as i32,
-                        location.latitude,
-                        location.longitude,
-                        location.accuracy,
-                        independent,
-                    ])?;
-
-                    if location.timestamp > newest_timestamp {
-                        newest_timestamp = location.timestamp;
-                        newest_location_id = sql::get_rowid2_with_conn(
-                            context,
-                            conn,
-                            "locations",
-                            "timestamp",
+                    if independent || !exists {
+                        stmt_insert.execute(params![
                             location.timestamp,
-                            "from_id",
                             contact_id as i32,
-                        );
+                            chat_id as i32,
+                            location.latitude,
+                            location.longitude,
+                            location.accuracy,
+                            independent,
+                        ])?;
+
+                        if location.timestamp > newest_timestamp {
+                            newest_timestamp = location.timestamp;
+                            newest_location_id = sql::get_rowid2_with_conn(
+                                context,
+                                conn,
+                                "locations",
+                                "timestamp",
+                                location.timestamp,
+                                "from_id",
+                                contact_id as i32,
+                            );
+                        }
                     }
                 }
-            }
-            Ok(newest_location_id)
-        },
-    )
+                Ok(newest_location_id)
+            },
+        )
+        .map_err(Into::into)
 }
 
 #[allow(non_snake_case)]

src/log.rs

@@ -1,167 +1,4 @@
-//! # Logging support
-
-use std::fmt;
-use std::fs;
-use std::io;
-use std::io::prelude::*;
-use std::path::{Path, PathBuf};
-
-/// A logger for a [Context].
-#[derive(Debug)]
-pub struct Logger {
-    created: std::time::Instant,
-    logdir: PathBuf,
-    logfile: String,
-    file_handle: fs::File,
-    max_files: u32,
-    max_filesize: usize,
-    bytes_written: usize,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum LogLevel {
-    Info,
-    Warning,
-    Error,
-}
-
-impl fmt::Display for LogLevel {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            LogLevel::Info => write!(f, "I"),
-            LogLevel::Warning => write!(f, "W"),
-            LogLevel::Error => write!(f, "E"),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Callsite<'a> {
-    pub file: &'a str,
-    pub line: u32,
-}
-
-impl fmt::Display for Callsite<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}:{}", self.file, self.line)
-    }
-}
-
-impl Logger {
-    pub fn new(logdir: PathBuf) -> Result<Logger, io::Error> {
-        let (fname, file) = Self::open(&logdir)?;
-        let max_files = 5;
-        Self::prune(&logdir, max_files)?;
-        Ok(Logger {
-            created: std::time::Instant::now(),
-            logdir,
-            logfile: fname,
-            file_handle: file,
-            max_files,
-            max_filesize: 4 * 1024 * 1024, // 4 Mb
-            bytes_written: 0,
-        })
-    }
-
-    /// Opens a new logfile, returning a tuple of (file_name, file_handle).
-    ///
-    /// This tries to create a new logfile based on the current time,
-    /// creating .0.log, .1.log etc if this file already exists (up to 32).
-    fn open(logdir: &Path) -> Result<(String, fs::File), io::Error> {
-        let basename =
-            chrono::offset::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Secs, true);
-        let mut fname = sanitize_filename::sanitize_with_options(
-            format!("{}.log", &basename),
-            sanitize_filename::Options {
-                truncate: true,
-                windows: true,
-                replacement: ".",
-            },
-        );
-        let mut counter = 0;
-        loop {
-            match std::fs::OpenOptions::new()
-                .write(true)
-                .create_new(true)
-                .open(logdir.join(&fname))
-            {
-                Ok(file) => {
-                    return Ok((fname, file));
-                }
-                Err(e) => {
-                    if counter >= 32 {
-                        return Err(e);
-                    } else {
-                        counter += 1;
-                        fname =
-                            sanitize_filename::sanitize(format!("{}-{}.log", &basename, counter));
-                        continue;
-                    }
-                }
-            }
-        }
-    }
-
-    /// Cleans up old logfiles.
-    fn prune(logdir: &Path, max_files: u32) -> Result<(), io::Error> {
-        let mut names: Vec<std::ffi::OsString> = Vec::new();
-        for dirent in fs::read_dir(logdir)? {
-            names.push(dirent?.file_name());
-        }
-        // Sorting like this sorts: 23.log, 24.1.log, 24.2.log,
-        // 24.log, 25.log.  That is 24.log is out of sequence.  Oh well.
-        names.sort();
-        names.reverse();
-        while names.len() > max_files as usize {
-            if let Some(name) = names.pop() {
-                fs::remove_file(logdir.join(name))?;
-            }
-        }
-        Ok(())
-    }
-
-    pub fn log(
-        &mut self,
-        level: LogLevel,
-        callsite: Callsite,
-        msg: &str,
-    ) -> Result<(), std::io::Error> {
-        if self.bytes_written > self.max_filesize {
-            self.flush()?;
-            let (fname, handle) = Self::open(&self.logdir)?;
-            self.logfile = fname;
-            self.file_handle = handle;
-            Self::prune(&self.logdir, self.max_files)?;
-        }
-        let thread = std::thread::current();
-        let msg = format!(
-            "{time:8.2} {level} {thid:?}/{thname} [{callsite}]: {msg}\n",
-            time = self.created.elapsed().as_secs_f64(),
-            level = level,
-            thid = thread.id(),
-            thname = thread.name().unwrap_or("unnamed"),
-            callsite = callsite,
-            msg = msg,
-        );
-        self.file_handle.write_all(msg.as_bytes())?;
-        self.bytes_written += msg.len();
-        Ok(())
-    }
-
-    pub fn flush(&mut self) -> Result<(), std::io::Error> {
-        self.file_handle.flush()
-    }
-}
-
-#[macro_export]
-macro_rules! callsite {
-    () => {
-        $crate::log::Callsite {
-            file: file!(),
-            line: line!(),
-        }
-    };
-}
+//! # Logging macros
 
 #[macro_export]
 macro_rules! info {
@@ -170,9 +7,6 @@ macro_rules! info {
     };
     ($ctx:expr, $msg:expr, $($args:expr),* $(,)?) => {{
         let formatted = format!($msg, $($args),*);
-        if let Ok(mut logger) = $ctx.logger.write() {
-            logger.log($crate::log::LogLevel::Info, callsite!(), &formatted).ok();
-        }
         emit_event!($ctx, $crate::Event::Info(formatted));
     }};
 }
@@ -184,9 +18,6 @@ macro_rules! warn {
     };
     ($ctx:expr, $msg:expr, $($args:expr),* $(,)?) => {{
         let formatted = format!($msg, $($args),*);
-        if let Ok(mut logger) = $ctx.logger.write() {
-            logger.log($crate::log::LogLevel::Warning, callsite!(), &formatted).ok();
-        }
         emit_event!($ctx, $crate::Event::Warning(formatted));
     }};
 }
@@ -198,9 +29,6 @@ macro_rules! error {
     };
     ($ctx:expr, $msg:expr, $($args:expr),* $(,)?) => {{
         let formatted = format!($msg, $($args),*);
-        if let Ok(mut logger) = $ctx.logger.write() {
-            logger.log($crate::log::LogLevel::Error, callsite!(), &formatted).ok();
-        }
         emit_event!($ctx, $crate::Event::Error(formatted));
     }};
 }
@@ -211,80 +39,3 @@ macro_rules! emit_event {
         $ctx.call_cb($event);
     };
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_basic_logging() {
-        let tmp = tempfile::tempdir().unwrap();
-        let dir = tmp.path();
-        let mut logger = Logger::new(dir.to_path_buf()).unwrap();
-        logger.log(LogLevel::Info, callsite!(), "foo").unwrap();
-        logger.log(LogLevel::Warning, callsite!(), "bar").unwrap();
-        logger.log(LogLevel::Error, callsite!(), "baz").unwrap();
-        logger.flush().unwrap();
-        let log = fs::read_to_string(logger.logdir.join(logger.logfile)).unwrap();
-        println!("{}", log);
-        let lines: Vec<&str> = log.lines().collect();
-
-        assert!(lines[0].contains(" I "));
-        assert!(lines[0].contains(format!("{:?}", std::thread::current().id()).as_str()));
-        assert!(lines[0]
-            .contains(format!("{}", std::thread::current().name().unwrap_or("unnamed")).as_str()));
-        assert!(lines[0].contains(&format!("src{}log.rs", std::path::MAIN_SEPARATOR)));
-        assert!(lines[0].contains("foo"));
-
-        assert!(lines[1].contains(" W "));
-        assert!(lines[1].contains(format!("{:?}", std::thread::current().id()).as_str()));
-        assert!(lines[1]
-            .contains(format!("{}", std::thread::current().name().unwrap_or("unnamed")).as_str()));
-        assert!(lines[1].contains(&format!("src{}log.rs", std::path::MAIN_SEPARATOR)));
-        assert!(lines[1].contains("bar"));
-
-        assert!(lines[2].contains(" E "));
-        assert!(lines[2].contains(format!("{:?}", std::thread::current().id()).as_str()));
-        assert!(lines[2]
-            .contains(format!("{}", std::thread::current().name().unwrap_or("unnamed")).as_str()));
-        assert!(lines[2].contains(&format!("src{}log.rs", std::path::MAIN_SEPARATOR)));
-        assert!(lines[2].contains("baz"));
-    }
-
-    #[test]
-    fn test_reopen_logfile() {
-        let tmp = tempfile::tempdir().unwrap();
-        let dir = tmp.path();
-        let mut logger = Logger::new(dir.to_path_buf()).unwrap();
-        logger.max_filesize = 5;
-
-        let fname0 = logger.logfile.clone();
-        assert!(fname0.ends_with(".log"));
-        logger
-            .log(LogLevel::Info, callsite!(), "more than 5 bytes are written")
-            .unwrap();
-        logger.log(LogLevel::Info, callsite!(), "2nd msg").unwrap();
-        let fname1 = logger.logfile.clone();
-        assert!(fname1.ends_with("-1.log"));
-        assert_ne!(fname0, fname1);
-        let log0 = fs::read_to_string(logger.logdir.join(&fname0)).unwrap();
-        assert!(log0.contains("more than 5 bytes are written"));
-        let log1 = fs::read_to_string(logger.logdir.join(&fname1)).unwrap();
-        assert!(log1.contains("2nd msg"));
-    }
-
-    #[test]
-    fn test_prune() {
-        let tmp = tempfile::tempdir().unwrap();
-        let dir = tmp.path();
-        Logger::new(dir.to_path_buf()).unwrap();
-        Logger::new(dir.to_path_buf()).unwrap();
-        Logger::new(dir.to_path_buf()).unwrap();
-        Logger::new(dir.to_path_buf()).unwrap();
-        let dirents0: Vec<fs::DirEntry> = fs::read_dir(&dir).unwrap().map(|r| r.unwrap()).collect();
-        assert_eq!(dirents0.len(), 4);
-        Logger::prune(&dir, 3).unwrap();
-        let dirents1: Vec<fs::DirEntry> = fs::read_dir(&dir).unwrap().map(|r| r.unwrap()).collect();
-        assert_eq!(dirents1.len(), 3);
-    }
-}

src/message.rs

@@ -7,12 +7,12 @@ use crate::chat::{self, Chat};
 use crate::constants::*;
 use crate::contact::*;
 use crate::context::*;
-use crate::dc_mimeparser::SystemMessage;
 use crate::dc_tools::*;
 use crate::error::Error;
 use crate::events::Event;
 use crate::job::*;
 use crate::lot::{Lot, LotState, Meaning};
+use crate::mimeparser::SystemMessage;
 use crate::param::*;
 use crate::pgp::*;
 use crate::sql;
@@ -191,82 +191,85 @@ impl Message {
             !id.is_special(),
             "Can not load special message IDs from DB."
         );
-        context.sql.query_row(
-            concat!(
-                "SELECT",
-                "    m.id AS id,",
-                "    rfc724_mid AS rfc724mid,",
-                "    m.mime_in_reply_to AS mime_in_reply_to,",
-                "    m.server_folder AS server_folder,",
-                "    m.server_uid AS server_uid,",
-                "    m.chat_id AS chat_id,",
-                "    m.from_id AS from_id,",
-                "    m.to_id AS to_id,",
-                "    m.timestamp AS timestamp,",
-                "    m.timestamp_sent AS timestamp_sent,",
-                "    m.timestamp_rcvd AS timestamp_rcvd,",
-                "    m.type AS type,",
-                "    m.state AS state,",
-                "    m.msgrmsg AS msgrmsg,",
-                "    m.txt AS txt,",
-                "    m.param AS param,",
-                "    m.starred AS starred,",
-                "    m.hidden AS hidden,",
-                "    m.location_id AS location,",
-                "    c.blocked AS blocked",
-                " FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id",
-                " WHERE m.id=?;"
-            ),
-            params![id],
-            |row| {
-                let mut msg = Message::default();
-                // msg.id = row.get::<_, AnyMsgId>("id")?;
-                msg.id = row.get("id")?;
-                msg.rfc724_mid = row.get::<_, String>("rfc724mid")?;
-                msg.in_reply_to = row.get::<_, Option<String>>("mime_in_reply_to")?;
-                msg.server_folder = row.get::<_, Option<String>>("server_folder")?;
-                msg.server_uid = row.get("server_uid")?;
-                msg.chat_id = row.get("chat_id")?;
-                msg.from_id = row.get("from_id")?;
-                msg.to_id = row.get("to_id")?;
-                msg.timestamp_sort = row.get("timestamp")?;
-                msg.timestamp_sent = row.get("timestamp_sent")?;
-                msg.timestamp_rcvd = row.get("timestamp_rcvd")?;
-                msg.type_0 = row.get("type")?;
-                msg.state = row.get("state")?;
-                msg.is_dc_message = row.get("msgrmsg")?;
+        context
+            .sql
+            .query_row(
+                concat!(
+                    "SELECT",
+                    "    m.id AS id,",
+                    "    rfc724_mid AS rfc724mid,",
+                    "    m.mime_in_reply_to AS mime_in_reply_to,",
+                    "    m.server_folder AS server_folder,",
+                    "    m.server_uid AS server_uid,",
+                    "    m.chat_id AS chat_id,",
+                    "    m.from_id AS from_id,",
+                    "    m.to_id AS to_id,",
+                    "    m.timestamp AS timestamp,",
+                    "    m.timestamp_sent AS timestamp_sent,",
+                    "    m.timestamp_rcvd AS timestamp_rcvd,",
+                    "    m.type AS type,",
+                    "    m.state AS state,",
+                    "    m.msgrmsg AS msgrmsg,",
+                    "    m.txt AS txt,",
+                    "    m.param AS param,",
+                    "    m.starred AS starred,",
+                    "    m.hidden AS hidden,",
+                    "    m.location_id AS location,",
+                    "    c.blocked AS blocked",
+                    " FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id",
+                    " WHERE m.id=?;"
+                ),
+                params![id],
+                |row| {
+                    let mut msg = Message::default();
+                    // msg.id = row.get::<_, AnyMsgId>("id")?;
+                    msg.id = row.get("id")?;
+                    msg.rfc724_mid = row.get::<_, String>("rfc724mid")?;
+                    msg.in_reply_to = row.get::<_, Option<String>>("mime_in_reply_to")?;
+                    msg.server_folder = row.get::<_, Option<String>>("server_folder")?;
+                    msg.server_uid = row.get("server_uid")?;
+                    msg.chat_id = row.get("chat_id")?;
+                    msg.from_id = row.get("from_id")?;
+                    msg.to_id = row.get("to_id")?;
+                    msg.timestamp_sort = row.get("timestamp")?;
+                    msg.timestamp_sent = row.get("timestamp_sent")?;
+                    msg.timestamp_rcvd = row.get("timestamp_rcvd")?;
+                    msg.type_0 = row.get("type")?;
+                    msg.state = row.get("state")?;
+                    msg.is_dc_message = row.get("msgrmsg")?;
 
-                let text;
-                if let rusqlite::types::ValueRef::Text(buf) = row.get_raw("txt") {
-                    if let Ok(t) = String::from_utf8(buf.to_vec()) {
-                        text = t;
+                    let text;
+                    if let rusqlite::types::ValueRef::Text(buf) = row.get_raw("txt") {
+                        if let Ok(t) = String::from_utf8(buf.to_vec()) {
+                            text = t;
+                        } else {
+                            warn!(
+                                context,
+                                concat!(
+                                    "dc_msg_load_from_db: could not get ",
+                                    "text column as non-lossy utf8 id {}"
+                                ),
+                                id
+                            );
+                            text = String::from_utf8_lossy(buf).into_owned();
+                        }
                     } else {
-                        warn!(
-                            context,
-                            concat!(
-                                "dc_msg_load_from_db: could not get ",
-                                "text column as non-lossy utf8 id {}"
-                            ),
-                            id
-                        );
-                        text = String::from_utf8_lossy(buf).into_owned();
+                        text = "".to_string();
                     }
-                } else {
-                    text = "".to_string();
-                }
-                msg.text = Some(text);
+                    msg.text = Some(text);
 
-                msg.param = row.get::<_, String>("param")?.parse().unwrap_or_default();
-                msg.starred = row.get("starred")?;
-                msg.hidden = row.get("hidden")?;
-                msg.location_id = row.get("location")?;
-                msg.chat_blocked = row
-                    .get::<_, Option<Blocked>>("blocked")?
-                    .unwrap_or_default();
+                    msg.param = row.get::<_, String>("param")?.parse().unwrap_or_default();
+                    msg.starred = row.get("starred")?;
+                    msg.hidden = row.get("hidden")?;
+                    msg.location_id = row.get("location")?;
+                    msg.chat_blocked = row
+                        .get::<_, Option<Blocked>>("blocked")?
+                        .unwrap_or_default();
 
-                Ok(msg)
-            },
-        )
+                    Ok(msg)
+                },
+            )
+            .map_err(Into::into)
     }
 
     pub fn delete_from_db(context: &Context, msg_id: MsgId) {
@@ -306,6 +309,32 @@ impl Message {
         self.param.get_path(Param::File, context).unwrap_or(None)
     }
 
+    pub fn try_calc_and_set_dimensions(&mut self, context: &Context) -> Result<(), Error> {
+        if chat::msgtype_has_file(self.type_0) {
+            let file_param = self.param.get_path(Param::File, context)?;
+            if let Some(path_and_filename) = file_param {
+                if (self.type_0 == Viewtype::Image || self.type_0 == Viewtype::Gif)
+                    && !self.param.exists(Param::Width)
+                {
+                    self.param.set_int(Param::Width, 0);
+                    self.param.set_int(Param::Height, 0);
+
+                    if let Ok(buf) = dc_read_file(context, path_and_filename) {
+                        if let Ok((width, height)) = dc_get_filemeta(&buf) {
+                            self.param.set_int(Param::Width, width as i32);
+                            self.param.set_int(Param::Height, height as i32);
+                        }
+                    }
+
+                    if !self.id.is_unset() {
+                        self.save_param_to_disk(context);
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
     /// Check if a message has a location bound to it.
     /// These messages are also returned by dc_get_locations()
     /// and the UI may decide to display a special icon beside such messages,
@@ -428,8 +457,8 @@ impl Message {
             return ret;
         };
 
-        let contact = if self.from_id != DC_CONTACT_ID_SELF as libc::c_uint
-            && ((*chat).typ == Chattype::Group || (*chat).typ == Chattype::VerifiedGroup)
+        let contact = if self.from_id != DC_CONTACT_ID_SELF as u32
+            && (chat.typ == Chattype::Group || chat.typ == Chattype::VerifiedGroup)
         {
             Contact::get_by_id(context, self.from_id).ok()
         } else {
@@ -441,11 +470,11 @@ impl Message {
         ret
     }
 
-    pub fn get_summarytext(&mut self, context: &Context, approx_characters: usize) -> String {
+    pub fn get_summarytext(&self, context: &Context, approx_characters: usize) -> String {
         get_summarytext_by_raw(
             self.type_0,
             self.text.as_ref(),
-            &mut self.param,
+            &self.param,
             approx_characters,
             context,
         )
@@ -473,8 +502,8 @@ impl Message {
 
     pub fn is_info(&self) -> bool {
         let cmd = self.param.get_cmd();
-        self.from_id == DC_CONTACT_ID_INFO as libc::c_uint
-            || self.to_id == DC_CONTACT_ID_INFO as libc::c_uint
+        self.from_id == DC_CONTACT_ID_INFO as u32
+            || self.to_id == DC_CONTACT_ID_INFO as u32
             || cmd != SystemMessage::Unknown && cmd != SystemMessage::AutocryptSetupMessage
     }
 
@@ -701,7 +730,7 @@ pub fn get_msg_info(context: &Context, msg_id: MsgId) -> String {
     ret += &format!(" by {}", name);
     ret += "\n";
 
-    if msg.from_id != DC_CONTACT_ID_SELF as libc::c_uint {
+    if msg.from_id != DC_CONTACT_ID_SELF as u32 {
         let s = dc_timestamp_to_str(if 0 != msg.timestamp_rcvd {
             msg.timestamp_rcvd
         } else {
@@ -984,7 +1013,7 @@ pub fn star_msgs(context: &Context, msg_ids: &[MsgId], star: bool) -> bool {
 pub fn get_summarytext_by_raw(
     viewtype: Viewtype,
     text: Option<impl AsRef<str>>,
-    param: &mut Params,
+    param: &Params,
     approx_characters: usize,
     context: &Context,
 ) -> String {
@@ -1108,7 +1137,7 @@ pub fn mdn_from_ext(
         return None;
     }
 
-    if let Ok((msg_id, chat_id, chat_type, msg_state)) = context.sql.query_row(
+    let res = context.sql.query_row(
         concat!(
             "SELECT",
             "    m.id AS msg_id,",
@@ -1128,7 +1157,12 @@ pub fn mdn_from_ext(
                 row.get::<_, MessageState>("state")?,
             ))
         },
-    ) {
+    );
+    if let Err(ref err) = res {
+        info!(context, "Failed to select MDN {:?}", err);
+    }
+
+    if let Ok((msg_id, chat_id, chat_type, msg_state)) = res {
         let mut read_by_all = false;
 
         // if already marked as MDNS_RCVD msgstate_can_fail() returns false.
@@ -1193,7 +1227,7 @@ pub fn mdn_from_ext(
 }
 
 /// The number of messages assigned to real chat (!=deaddrop, !=trash)
-pub fn get_real_msg_cnt(context: &Context) -> libc::c_int {
+pub fn get_real_msg_cnt(context: &Context) -> i32 {
     match context.sql.query_row(
         "SELECT COUNT(*) \
          FROM msgs m  LEFT JOIN chats c ON c.id=m.chat_id \
@@ -1209,7 +1243,7 @@ pub fn get_real_msg_cnt(context: &Context) -> libc::c_int {
     }
 }
 
-pub fn get_deaddrop_msg_cnt(context: &Context) -> libc::size_t {
+pub fn get_deaddrop_msg_cnt(context: &Context) -> usize {
     match context.sql.query_row(
         "SELECT COUNT(*) \
          FROM msgs m LEFT JOIN chats c ON c.id=m.chat_id \
@@ -1217,7 +1251,7 @@ pub fn get_deaddrop_msg_cnt(context: &Context) -> libc::size_t {
         rusqlite::NO_PARAMS,
         |row| row.get::<_, isize>(0),
     ) {
-        Ok(res) => res as libc::size_t,
+        Ok(res) => res as usize,
         Err(err) => {
             error!(context, "dc_get_deaddrop_msg_cnt() failed. {}", err);
             0
@@ -1225,7 +1259,7 @@ pub fn get_deaddrop_msg_cnt(context: &Context) -> libc::size_t {
     }
 }
 
-pub fn rfc724_mid_cnt(context: &Context, rfc724_mid: &str) -> libc::c_int {
+pub fn rfc724_mid_cnt(context: &Context, rfc724_mid: &str) -> i32 {
     // check the number of messages with the same rfc724_mid
     match context.sql.query_row(
         "SELECT COUNT(*) FROM msgs WHERE rfc724_mid=?;",
@@ -1246,17 +1280,20 @@ pub(crate) fn rfc724_mid_exists(
 ) -> Result<(String, u32, MsgId), Error> {
     ensure!(!rfc724_mid.is_empty(), "empty rfc724_mid");
 
-    context.sql.query_row(
-        "SELECT server_folder, server_uid, id FROM msgs WHERE rfc724_mid=?",
-        &[rfc724_mid],
-        |row| {
-            let server_folder = row.get::<_, Option<String>>(0)?.unwrap_or_default();
-            let server_uid = row.get(1)?;
-            let msg_id: MsgId = row.get(2)?;
+    context
+        .sql
+        .query_row(
+            "SELECT server_folder, server_uid, id FROM msgs WHERE rfc724_mid=?",
+            &[rfc724_mid],
+            |row| {
+                let server_folder = row.get::<_, Option<String>>(0)?.unwrap_or_default();
+                let server_uid = row.get(1)?;
+                let msg_id: MsgId = row.get(2)?;
 
-            Ok((server_folder, server_uid, msg_id))
-        },
-    )
+                Ok((server_folder, server_uid, msg_id))
+            },
+        )
+        .map_err(Into::into)
 }
 
 pub fn update_server_uid(

src/oauth2.rs

@@ -355,6 +355,8 @@ fn normalize_addr(addr: &str) -> &str {
 mod tests {
     use super::*;
 
+    use crate::test_utils::*;
+
     #[test]
     fn test_normalize_addr() {
         assert_eq!(normalize_addr(" hello@mail.de  "), "hello@mail.de");
@@ -384,4 +386,34 @@ mod tests {
 
         assert_eq!(Oauth2::from_address("hello@web.de"), None);
     }
+
+    #[test]
+    fn test_dc_get_oauth2_addr() {
+        let ctx = dummy_context();
+        let addr = "dignifiedquire@gmail.com";
+        let code = "fail";
+        let res = dc_get_oauth2_addr(&ctx.ctx, addr, code);
+        // this should fail as it is an invalid password
+        assert_eq!(res, None);
+    }
+
+    #[test]
+    fn test_dc_get_oauth2_url() {
+        let ctx = dummy_context();
+        let addr = "dignifiedquire@gmail.com";
+        let redirect_uri = "chat.delta:/com.b44t.messenger";
+        let res = dc_get_oauth2_url(&ctx.ctx, addr, redirect_uri);
+
+        assert_eq!(res, Some("https://accounts.google.com/o/oauth2/auth?client_id=959970109878%2D4mvtgf6feshskf7695nfln6002mom908%2Eapps%2Egoogleusercontent%2Ecom&redirect_uri=chat%2Edelta%3A%2Fcom%2Eb44t%2Emessenger&response_type=code&scope=https%3A%2F%2Fmail.google.com%2F%20email&access_type=offline".into()));
+    }
+
+    #[test]
+    fn test_dc_get_oauth2_token() {
+        let ctx = dummy_context();
+        let addr = "dignifiedquire@gmail.com";
+        let code = "fail";
+        let res = dc_get_oauth2_access_token(&ctx.ctx, addr, code, false);
+        // this should fail as it is an invalid password
+        assert_eq!(res, None);
+    }
 }

src/param.rs

@@ -7,8 +7,8 @@ use num_traits::FromPrimitive;
 
 use crate::blob::{BlobError, BlobObject};
 use crate::context::Context;
-use crate::dc_mimeparser::SystemMessage;
 use crate::error;
+use crate::mimeparser::SystemMessage;
 
 /// Available param keys.
 #[derive(PartialEq, Eq, Debug, Clone, Copy, Hash, PartialOrd, Ord, FromPrimitive)]
@@ -321,7 +321,6 @@ mod tests {
     use std::fs;
     use std::path::Path;
 
-    use crate::blob::BlobErrorKind;
     use crate::test_utils::*;
 
     #[test]
@@ -404,7 +403,10 @@ mod tests {
 
         // Blob does not exist yet, expect BlobError.
         let err = p.get_blob(Param::File, &t.ctx, false).unwrap_err();
-        assert_eq!(err.kind(), BlobErrorKind::WrongBlobdir);
+        match err {
+            BlobError::WrongBlobdir { .. } => (),
+            _ => panic!("wrong error type/variant: {:?}", err),
+        }
 
         fs::write(fname, b"boo").unwrap();
         let blob = p.get_blob(Param::File, &t.ctx, true).unwrap().unwrap();

src/peerstate.rs

@@ -8,12 +8,14 @@ use crate::aheader::*;
 use crate::chat::*;
 use crate::constants::*;
 use crate::context::Context;
-use crate::error::*;
 use crate::key::*;
 use crate::sql::{self, Sql};
 
-pub const DC_PS_GOSSIP_KEY: u32 = 0;
-pub const DC_PS_PUBLIC_KEY: u32 = 1;
+#[derive(Debug)]
+pub enum PeerstateKeyType {
+    GossipKey,
+    PublicKey,
+}
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy, FromPrimitive)]
 #[repr(u8)]
@@ -26,7 +28,7 @@ pub enum PeerstateVerifiedStatus {
 /// Peerstate represents the state of an Autocrypt peer.
 pub struct Peerstate<'a> {
     pub context: &'a Context,
-    pub addr: Option<String>,
+    pub addr: String,
     pub last_seen: i64,
     pub last_seen_autocrypt: i64,
     pub prefer_encrypt: EncryptPreference,
@@ -98,10 +100,10 @@ pub enum DegradeEvent {
 }
 
 impl<'a> Peerstate<'a> {
-    pub fn new(context: &'a Context) -> Self {
+    pub fn new(context: &'a Context, addr: String) -> Self {
         Peerstate {
             context,
-            addr: None,
+            addr,
             last_seen: 0,
             last_seen_autocrypt: 0,
             prefer_encrypt: Default::default(),
@@ -118,9 +120,8 @@ impl<'a> Peerstate<'a> {
     }
 
     pub fn from_header(context: &'a Context, header: &Aheader, message_time: i64) -> Self {
-        let mut res = Self::new(context);
+        let mut res = Self::new(context, header.addr.clone());
 
-        res.addr = Some(header.addr.clone());
         res.last_seen = message_time;
         res.last_seen_autocrypt = message_time;
         res.to_save = Some(ToSave::All);
@@ -132,9 +133,8 @@ impl<'a> Peerstate<'a> {
     }
 
     pub fn from_gossip(context: &'a Context, gossip_header: &Aheader, message_time: i64) -> Self {
-        let mut res = Self::new(context);
+        let mut res = Self::new(context, gossip_header.addr.clone());
 
-        res.addr = Some(gossip_header.addr.clone());
         res.gossip_timestamp = message_time;
         res.to_save = Some(ToSave::All);
         res.gossip_key = Some(gossip_header.public_key.clone());
@@ -177,9 +177,8 @@ impl<'a> Peerstate<'a> {
                 public_key, gossip_timestamp, gossip_key, public_key_fingerprint,
                 gossip_key_fingerprint, verified_key, verified_key_fingerprint
                 */
-                let mut res = Self::new(context);
+                let mut res = Self::new(context, row.get(0)?);
 
-                res.addr = Some(row.get(0)?);
                 res.last_seen = row.get(1)?;
                 res.last_seen_autocrypt = row.get(2)?;
                 res.prefer_encrypt = EncryptPreference::from_i32(row.get(3)?).unwrap_or_default();
@@ -273,9 +272,7 @@ impl<'a> Peerstate<'a> {
     }
 
     pub fn apply_header(&mut self, header: &Aheader, message_time: i64) {
-        if self.addr.is_none()
-            || self.addr.as_ref().unwrap().to_lowercase() != header.addr.to_lowercase()
-        {
+        if self.addr.to_lowercase() != header.addr.to_lowercase() {
             return;
         }
 
@@ -305,9 +302,7 @@ impl<'a> Peerstate<'a> {
     }
 
     pub fn apply_gossip(&mut self, gossip_header: &Aheader, message_time: i64) {
-        if self.addr.is_none()
-            || self.addr.as_ref().unwrap().to_lowercase() != gossip_header.addr.to_lowercase()
-        {
+        if self.addr.to_lowercase() != gossip_header.addr.to_lowercase() {
             return;
         }
 
@@ -323,19 +318,17 @@ impl<'a> Peerstate<'a> {
     }
 
     pub fn render_gossip_header(&self, min_verified: PeerstateVerifiedStatus) -> Option<String> {
-        if let Some(ref addr) = self.addr {
-            if let Some(key) = self.peek_key(min_verified) {
-                // TODO: avoid cloning
-                let header = Aheader::new(
-                    addr.to_string(),
-                    key.clone(),
-                    EncryptPreference::NoPreference,
-                );
-                return Some(header.to_string());
-            }
+        if let Some(key) = self.peek_key(min_verified) {
+            // TODO: avoid cloning
+            let header = Aheader::new(
+                self.addr.clone(),
+                key.clone(),
+                EncryptPreference::NoPreference,
+            );
+            Some(header.to_string())
+        } else {
+            None
         }
-
-        None
     }
 
     pub fn peek_key(&self, min_verified: PeerstateVerifiedStatus) -> Option<&Key> {
@@ -355,45 +348,49 @@ impl<'a> Peerstate<'a> {
 
     pub fn set_verified(
         &mut self,
-        which_key: u32,
+        which_key: PeerstateKeyType,
         fingerprint: &str,
         verified: PeerstateVerifiedStatus,
     ) -> bool {
-        let mut success = false;
-        if !(which_key != DC_PS_GOSSIP_KEY && which_key != DC_PS_PUBLIC_KEY
-            || verified != PeerstateVerifiedStatus::BidirectVerified)
-        {
-            if which_key == DC_PS_PUBLIC_KEY
-                && self.public_key_fingerprint.is_some()
-                && self.public_key_fingerprint.as_ref().unwrap() == fingerprint
-            {
-                self.to_save = Some(ToSave::All);
-                self.verified_key = self.public_key.clone();
-                self.verified_key_fingerprint = self.public_key_fingerprint.clone();
-                success = true;
-            }
-            if which_key == DC_PS_GOSSIP_KEY
-                && self.gossip_key_fingerprint.is_some()
-                && self.gossip_key_fingerprint.as_ref().unwrap() == fingerprint
-            {
-                self.to_save = Some(ToSave::All);
-                self.verified_key = self.gossip_key.clone();
-                self.verified_key_fingerprint = self.gossip_key_fingerprint.clone();
-                success = true;
+        if verified == PeerstateVerifiedStatus::BidirectVerified {
+            match which_key {
+                PeerstateKeyType::PublicKey => {
+                    if self.public_key_fingerprint.is_some()
+                        && self.public_key_fingerprint.as_ref().unwrap() == fingerprint
+                    {
+                        self.to_save = Some(ToSave::All);
+                        self.verified_key = self.public_key.clone();
+                        self.verified_key_fingerprint = self.public_key_fingerprint.clone();
+                        true
+                    } else {
+                        false
+                    }
+                }
+                PeerstateKeyType::GossipKey => {
+                    if self.gossip_key_fingerprint.is_some()
+                        && self.gossip_key_fingerprint.as_ref().unwrap() == fingerprint
+                    {
+                        self.to_save = Some(ToSave::All);
+                        self.verified_key = self.gossip_key.clone();
+                        self.verified_key_fingerprint = self.gossip_key_fingerprint.clone();
+                        true
+                    } else {
+                        false
+                    }
+                }
             }
+        } else {
+            false
         }
-
-        success
     }
 
-    pub fn save_to_db(&self, sql: &Sql, create: bool) -> Result<()> {
-        ensure!(!self.addr.is_none(), "self.addr is not configured");
+    pub fn save_to_db(&self, sql: &Sql, create: bool) -> crate::sql::Result<()> {
         if create {
             sql::execute(
                 self.context,
                 sql,
                 "INSERT INTO acpeerstates (addr) VALUES(?);",
-                params![self.addr.as_ref().unwrap()],
+                params![self.addr],
             )?;
         }
 
@@ -471,7 +468,7 @@ mod tests {
 
         let mut peerstate = Peerstate {
             context: &ctx.ctx,
-            addr: Some(addr.into()),
+            addr: addr.into(),
             last_seen: 10,
             last_seen_autocrypt: 11,
             prefer_encrypt: EncryptPreference::Mutual,
@@ -516,7 +513,7 @@ mod tests {
 
         let peerstate = Peerstate {
             context: &ctx.ctx,
-            addr: Some(addr.into()),
+            addr: addr.into(),
             last_seen: 10,
             last_seen_autocrypt: 11,
             prefer_encrypt: EncryptPreference::Mutual,
@@ -554,7 +551,7 @@ mod tests {
 
         let mut peerstate = Peerstate {
             context: &ctx.ctx,
-            addr: Some(addr.into()),
+            addr: addr.into(),
             last_seen: 10,
             last_seen_autocrypt: 11,
             prefer_encrypt: EncryptPreference::Mutual,

src/qr.rs

@@ -139,24 +139,20 @@ fn decode_openpgp(context: &Context, qr: &str) -> Lot {
     if invitenumber.is_none() || auth.is_none() {
         if let Some(peerstate) = peerstate {
             lot.state = LotState::QrFprOk;
-            let addr = peerstate
-                .addr
-                .as_ref()
-                .map(|s| s.as_str())
-                .unwrap_or_else(|| "");
 
-            lot.id = Contact::add_or_lookup(context, name, addr, Origin::UnhandledQrScan)
-                .map(|(id, _)| id)
-                .unwrap_or_default();
+            lot.id = Contact::add_or_lookup(
+                context,
+                name,
+                peerstate.addr.clone(),
+                Origin::UnhandledQrScan,
+            )
+            .map(|(id, _)| id)
+            .unwrap_or_default();
 
             let (id, _) = chat::create_or_lookup_by_contact_id(context, lot.id, Blocked::Deaddrop)
                 .unwrap_or_default();
 
-            chat::add_info_msg(
-                context,
-                id,
-                format!("{} verified.", peerstate.addr.unwrap_or_default()),
-            );
+            chat::add_info_msg(context, id, format!("{} verified.", peerstate.addr));
         } else {
             lot.state = LotState::QrFprWithoutAddr;
             lot.text1 = Some(dc_format_fingerprint(&fingerprint));

src/securejoin.rs

@@ -8,13 +8,13 @@ use crate::config::*;
 use crate::constants::*;
 use crate::contact::*;
 use crate::context::Context;
-use crate::dc_mimeparser::*;
 use crate::e2ee::*;
 use crate::error::Error;
 use crate::events::Event;
 use crate::key::*;
 use crate::lot::LotState;
 use crate::message::Message;
+use crate::mimeparser::*;
 use crate::param::*;
 use crate::peerstate::*;
 use crate::qr::check_qr;
@@ -242,7 +242,8 @@ pub fn dc_join_securejoin(context: &Context, qr: &str) -> u32 {
 
     // Bob -> Alice
     while !context.shall_stop_ongoing() {
-        std::thread::sleep(std::time::Duration::new(0, 3_000_000));
+        // Don't sleep too long, the user is waiting.
+        std::thread::sleep(std::time::Duration::from_millis(200));
     }
     cleanup(&context, contact_chat_id, true, join_vg)
 }
@@ -318,35 +319,54 @@ fn fingerprint_equals_sender(
     false
 }
 
-/* library private: secure-join */
-pub fn handle_securejoin_handshake(
+pub(crate) struct HandshakeMessageStatus {
+    pub(crate) hide_this_msg: bool,
+    pub(crate) delete_this_msg: bool,
+    pub(crate) stop_ongoing_process: bool,
+    pub(crate) bob_securejoin_success: Option<bool>,
+}
+
+impl Default for HandshakeMessageStatus {
+    fn default() -> Self {
+        Self {
+            hide_this_msg: true,
+            delete_this_msg: false,
+            stop_ongoing_process: false,
+            bob_securejoin_success: None,
+        }
+    }
+}
+
+/// Handle incoming secure-join handshake.
+pub(crate) fn handle_securejoin_handshake(
     context: &Context,
     mimeparser: &MimeParser,
     contact_id: u32,
-) -> libc::c_int {
+) -> Result<HandshakeMessageStatus, Error> {
     let own_fingerprint: String;
 
-    if contact_id <= DC_CONTACT_ID_LAST_SPECIAL {
-        return 0;
-    }
-    let step = match mimeparser.lookup_optional_field("Secure-Join") {
-        Some(s) => s,
-        None => {
-            return 0;
-        }
-    };
+    ensure!(
+        contact_id > DC_CONTACT_ID_LAST_SPECIAL,
+        "handle_securejoin_handshake(): called with special contact id"
+    );
+    let step = mimeparser
+        .lookup_field("Secure-Join")
+        .ok_or_else(|| format_err!("This message is not a Secure-Join message"))?;
+
     info!(
         context,
         ">>>>>>>>>>>>>>>>>>>>>>>>> secure-join message \'{}\' received", step,
     );
+
     let (contact_chat_id, contact_chat_id_blocked) =
         chat::create_or_lookup_by_contact_id(context, contact_id, Blocked::Not).unwrap_or_default();
 
     if contact_chat_id_blocked != Blocked::Not {
         chat::unblock(context, contact_chat_id);
     }
-    let mut ret: libc::c_int = DC_HANDSHAKE_STOP_NORMAL_PROCESSING;
+
     let join_vg = step.starts_with("vg-");
+    let mut ret = HandshakeMessageStatus::default();
 
     match step.as_str() {
         "vg-request" | "vc-request" => {
@@ -358,16 +378,16 @@ pub fn handle_securejoin_handshake(
             // it just ensures, we have Bobs key now. If we do _not_ have the key because eg. MitM has removed it,
             // send_message() will fail with the error "End-to-end-encryption unavailable unexpectedly.", so, there is no additional check needed here.
             // verify that the `Secure-Join-Invitenumber:`-header matches invitenumber written to the QR code
-            let invitenumber = match mimeparser.lookup_optional_field("Secure-Join-Invitenumber") {
+            let invitenumber = match mimeparser.lookup_field("Secure-Join-Invitenumber") {
                 Some(n) => n,
                 None => {
                     warn!(context, "Secure-join denied (invitenumber missing).",);
-                    return ret;
+                    return Ok(ret);
                 }
             };
             if !token::exists(context, token::Namespace::InviteNumber, &invitenumber) {
                 warn!(context, "Secure-join denied (bad invitenumber).",);
-                return ret;
+                return Ok(ret);
             }
             info!(context, "Secure-join requested.",);
 
@@ -393,7 +413,7 @@ pub fn handle_securejoin_handshake(
             if cond {
                 warn!(context, "auth-required message out of sync.",);
                 // no error, just aborted somehow or a mail from another handshake
-                return ret;
+                return Ok(ret);
             }
             let scanned_fingerprint_of_alice = get_qr_attr!(context, fingerprint).to_string();
             let auth = get_qr_attr!(context, auth).to_string();
@@ -408,8 +428,9 @@ pub fn handle_securejoin_handshake(
                         "Not encrypted."
                     },
                 );
-                end_bobs_joining(context, DC_BOB_ERROR);
-                return ret;
+                ret.stop_ongoing_process = true;
+                ret.bob_securejoin_success = Some(false);
+                return Ok(ret);
             }
             if !fingerprint_equals_sender(context, &scanned_fingerprint_of_alice, contact_chat_id) {
                 could_not_establish_secure_connection(
@@ -417,8 +438,9 @@ pub fn handle_securejoin_handshake(
                     contact_chat_id,
                     "Fingerprint mismatch on joiner-side.",
                 );
-                end_bobs_joining(context, DC_BOB_ERROR);
-                return ret;
+                ret.stop_ongoing_process = true;
+                ret.bob_securejoin_success = Some(false);
+                return Ok(ret);
             }
             info!(context, "Fingerprint verified.",);
             own_fingerprint = get_self_fingerprint(context).unwrap();
@@ -445,7 +467,7 @@ pub fn handle_securejoin_handshake(
             ====  Step 6 in "Out-of-band verified groups" protocol  ====
             ============================================================ */
             // verify that Secure-Join-Fingerprint:-header matches the fingerprint of Bob
-            let fingerprint = match mimeparser.lookup_optional_field("Secure-Join-Fingerprint") {
+            let fingerprint = match mimeparser.lookup_field("Secure-Join-Fingerprint") {
                 Some(fp) => fp,
                 None => {
                     could_not_establish_secure_connection(
@@ -453,7 +475,7 @@ pub fn handle_securejoin_handshake(
                         contact_chat_id,
                         "Fingerprint not provided.",
                     );
-                    return ret;
+                    return Ok(ret);
                 }
             };
             if !encrypted_and_signed(mimeparser, &fingerprint) {
@@ -462,7 +484,7 @@ pub fn handle_securejoin_handshake(
                     contact_chat_id,
                     "Auth not encrypted.",
                 );
-                return ret;
+                return Ok(ret);
             }
             if !fingerprint_equals_sender(context, &fingerprint, contact_chat_id) {
                 could_not_establish_secure_connection(
@@ -470,11 +492,11 @@ pub fn handle_securejoin_handshake(
                     contact_chat_id,
                     "Fingerprint mismatch on inviter-side.",
                 );
-                return ret;
+                return Ok(ret);
             }
             info!(context, "Fingerprint verified.",);
             // verify that the `Secure-Join-Auth:`-header matches the secret written to the QR code
-            let auth_0 = match mimeparser.lookup_optional_field("Secure-Join-Auth") {
+            let auth_0 = match mimeparser.lookup_field("Secure-Join-Auth") {
                 Some(auth) => auth,
                 None => {
                     could_not_establish_secure_connection(
@@ -482,12 +504,12 @@ pub fn handle_securejoin_handshake(
                         contact_chat_id,
                         "Auth not provided.",
                     );
-                    return ret;
+                    return Ok(ret);
                 }
             };
             if !token::exists(context, token::Namespace::Auth, &auth_0) {
                 could_not_establish_secure_connection(context, contact_chat_id, "Auth invalid.");
-                return ret;
+                return Ok(ret);
             }
             if mark_peer_as_verified(context, fingerprint).is_err() {
                 could_not_establish_secure_connection(
@@ -495,7 +517,7 @@ pub fn handle_securejoin_handshake(
                     contact_chat_id,
                     "Fingerprint mismatch on inviter-side.",
                 );
-                return ret;
+                return Ok(ret);
             }
             Contact::scaleup_origin_by_id(context, contact_id, Origin::SecurejoinInvited);
             info!(context, "Auth verified.",);
@@ -504,12 +526,13 @@ pub fn handle_securejoin_handshake(
             inviter_progress!(context, contact_id, 600);
             if join_vg {
                 let field_grpid = mimeparser
-                    .lookup_optional_field("Secure-Join-Group")
-                    .unwrap_or_default();
-                let (group_chat_id, _, _) = chat::get_chat_id_by_grpid(context, &field_grpid);
+                    .lookup_field("Secure-Join-Group")
+                    .map(|s| s.as_str())
+                    .unwrap_or_else(|| "");
+                let (group_chat_id, _, _) = chat::get_chat_id_by_grpid(context, field_grpid);
                 if group_chat_id == 0 {
                     error!(context, "Chat {} not found.", &field_grpid);
-                    return ret;
+                    return Ok(ret);
                 } else {
                     if let Err(err) =
                         chat::add_contact_to_chat_ex(context, group_chat_id, contact_id, true)
@@ -524,11 +547,11 @@ pub fn handle_securejoin_handshake(
         }
         "vg-member-added" | "vc-contact-confirm" => {
             if join_vg {
-                ret = DC_HANDSHAKE_CONTINUE_NORMAL_PROCESSING;
+                ret.hide_this_msg = false;
             }
             if context.bob.read().unwrap().expects != DC_VC_CONTACT_CONFIRM {
                 info!(context, "Message belongs to a different handshake.",);
-                return ret;
+                return Ok(ret);
             }
             let cond = {
                 let bob = context.bob.read().unwrap();
@@ -540,7 +563,7 @@ pub fn handle_securejoin_handshake(
                     context,
                     "Message out of sync or belongs to a different handshake.",
                 );
-                return ret;
+                return Ok(ret);
             }
             let scanned_fingerprint_of_alice = get_qr_attr!(context, fingerprint).to_string();
 
@@ -564,8 +587,8 @@ pub fn handle_securejoin_handshake(
                     contact_chat_id,
                     "Contact confirm message not encrypted.",
                 );
-                end_bobs_joining(context, DC_BOB_ERROR);
-                return ret;
+                ret.bob_securejoin_success = Some(false);
+                return Ok(ret);
             }
 
             if mark_peer_as_verified(context, &scanned_fingerprint_of_alice).is_err() {
@@ -574,16 +597,17 @@ pub fn handle_securejoin_handshake(
                     contact_chat_id,
                     "Fingerprint mismatch on joiner-side.",
                 );
-                return ret;
+                return Ok(ret);
             }
             Contact::scaleup_origin_by_id(context, contact_id, Origin::SecurejoinJoined);
             emit_event!(context, Event::ContactsChanged(None));
             let cg_member_added = mimeparser
-                .lookup_optional_field("Chat-Group-Member-Added")
-                .unwrap_or_default();
+                .lookup_field("Chat-Group-Member-Added")
+                .map(|s| s.as_str())
+                .unwrap_or_else(|| "");
             if join_vg && !addr_equals_self(context, cg_member_added) {
                 info!(context, "Message belongs to a different handshake (scaled up contact anyway to allow creation of group).");
-                return ret;
+                return Ok(ret);
             }
             secure_connection_established(context, contact_chat_id);
             context.bob.write().unwrap().expects = 0;
@@ -597,7 +621,8 @@ pub fn handle_securejoin_handshake(
                     "",
                 );
             }
-            end_bobs_joining(context, DC_BOB_SUCCESS);
+            ret.stop_ongoing_process = true;
+            ret.bob_securejoin_success = Some(true);
         }
         "vg-member-added-received" => {
             /* ============================================================
@@ -607,13 +632,14 @@ pub fn handle_securejoin_handshake(
             if let Ok(contact) = Contact::get_by_id(context, contact_id) {
                 if contact.is_verified(context) == VerifiedStatus::Unverified {
                     warn!(context, "vg-member-added-received invalid.",);
-                    return ret;
+                    return Ok(ret);
                 }
                 inviter_progress!(context, contact_id, 800);
                 inviter_progress!(context, contact_id, 1000);
                 let field_grpid = mimeparser
-                    .lookup_optional_field("Secure-Join-Group")
-                    .unwrap_or_default();
+                    .lookup_field("Secure-Join-Group")
+                    .map(|s| s.as_str())
+                    .unwrap_or_else(|| "");
                 let (group_chat_id, _, _) = chat::get_chat_id_by_grpid(context, &field_grpid);
                 context.call_cb(Event::SecurejoinMemberAdded {
                     chat_id: group_chat_id,
@@ -621,22 +647,19 @@ pub fn handle_securejoin_handshake(
                 });
             } else {
                 warn!(context, "vg-member-added-received invalid.",);
-                return ret;
+                return Ok(ret);
             }
         }
         _ => {
             warn!(context, "invalid step: {}", step);
         }
     }
-    if ret == DC_HANDSHAKE_STOP_NORMAL_PROCESSING {
-        ret |= DC_HANDSHAKE_ADD_DELETE_JOB;
-    }
-    ret
-}
 
-fn end_bobs_joining(context: &Context, status: libc::c_int) {
-    context.bob.write().unwrap().status = status;
-    context.stop_ongoing();
+    if ret.hide_this_msg {
+        ret.delete_this_msg = true;
+    }
+
+    Ok(ret)
 }
 
 fn secure_connection_established(context: &Context, contact_chat_id: u32) {
@@ -673,7 +696,7 @@ fn mark_peer_as_verified(context: &Context, fingerprint: impl AsRef<str>) -> Res
         Peerstate::from_fingerprint(context, &context.sql, fingerprint.as_ref())
     {
         if peerstate.set_verified(
-            DC_PS_PUBLIC_KEY,
+            PeerstateKeyType::PublicKey,
             fingerprint.as_ref(),
             PeerstateVerifiedStatus::BidirectVerified,
         ) {
@@ -743,11 +766,8 @@ pub fn handle_degrade_event(context: &Context, peerstate: &Peerstate) -> Result<
                 chat::create_or_lookup_by_contact_id(context, contact_id as u32, Blocked::Deaddrop)
                     .unwrap_or_default();
 
-            let peeraddr: &str = match peerstate.addr {
-                Some(ref addr) => &addr,
-                None => "",
-            };
-            let msg = context.stock_string_repl_str(StockMessage::ContactSetupChanged, peeraddr);
+            let msg = context
+                .stock_string_repl_str(StockMessage::ContactSetupChanged, peerstate.addr.clone());
 
             chat::add_info_msg(context, contact_chat_id, msg);
             emit_event!(context, Event::ChatModified(contact_chat_id));

src/smtp.rs

@@ -1,189 +0,0 @@
-use lettre::smtp::client::net::*;
-use lettre::*;
-
-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::oauth2::*;
-
-#[derive(DebugStub)]
-pub struct Smtp {
-    #[debug_stub(some = "SmtpTransport")]
-    transport: Option<lettre::smtp::SmtpTransport>,
-    transport_connected: bool,
-    /// Email address we are sending from.
-    from: Option<EmailAddress>,
-}
-
-impl Smtp {
-    /// Create a new Smtp instances.
-    pub fn new() -> Self {
-        Smtp {
-            transport: None,
-            transport_connected: false,
-            from: None,
-        }
-    }
-
-    /// Disconnect the SMTP transport and drop it entirely.
-    pub fn disconnect(&mut self) {
-        if self.transport.is_none() || !self.transport_connected {
-            return;
-        }
-
-        let mut transport = self.transport.take().unwrap();
-        transport.close();
-        self.transport_connected = false;
-    }
-
-    /// Check if a connection already exists.
-    pub fn is_connected(&self) -> bool {
-        self.transport.is_some()
-    }
-
-    /// Connect using the provided login params
-    pub fn connect(&mut self, context: &Context, lp: &LoginParam) -> Result<(), Error> {
-        if self.is_connected() {
-            warn!(context, "SMTP already connected.");
-            return Ok(());
-        }
-
-        if lp.send_server.is_empty() || lp.send_port == 0 {
-            context.call_cb(Event::ErrorNetwork("SMTP bad parameters.".into()));
-            bail!("SMTP Bad parameters");
-        }
-
-        self.from = match EmailAddress::new(lp.addr.clone()) {
-            Ok(addr) => Some(addr),
-            Err(err) => {
-                bail!("invalid login address {}: {}", lp.addr, err);
-            }
-        };
-
-        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 (creds, mechanism) = if 0 != lp.server_flags & (DC_LP_AUTH_OAUTH2 as i32) {
-            // oauth2
-            let addr = &lp.addr;
-            let send_pw = &lp.send_pw;
-            let access_token = dc_get_oauth2_access_token(context, addr, send_pw, false);
-            ensure!(
-                access_token.is_some(),
-                "could not get oaut2_access token addr={}",
-                addr
-            );
-            let user = &lp.send_user;
-            (
-                lettre::smtp::authentication::Credentials::new(
-                    user.to_string(),
-                    access_token.unwrap_or_default(),
-                ),
-                vec![lettre::smtp::authentication::Mechanism::Xoauth2],
-            )
-        } else {
-            // plain
-            let user = lp.send_user.clone();
-            let pw = lp.send_pw.clone();
-            (
-                lettre::smtp::authentication::Credentials::new(user, pw),
-                vec![
-                    lettre::smtp::authentication::Mechanism::Plain,
-                    lettre::smtp::authentication::Mechanism::Login,
-                ],
-            )
-        };
-
-        let security = if 0
-            != lp.server_flags & (DC_LP_SMTP_SOCKET_STARTTLS | DC_LP_SMTP_SOCKET_PLAIN) as i32
-        {
-            lettre::smtp::ClientSecurity::Opportunistic(tls_parameters)
-        } else {
-            lettre::smtp::ClientSecurity::Wrapper(tls_parameters)
-        };
-
-        match lettre::smtp::SmtpClient::new((domain.as_str(), port), security) {
-            Ok(client) => {
-                let client = client
-                    .smtp_utf8(true)
-                    .credentials(creds)
-                    .authentication_mechanism(mechanism)
-                    .connection_reuse(lettre::smtp::ConnectionReuseParameters::ReuseUnlimited);
-                let mut trans = client.transport();
-                match trans.connect() {
-                    Ok(()) => {
-                        self.transport = Some(trans);
-                        self.transport_connected = true;
-                        context.call_cb(Event::SmtpConnected(format!(
-                            "SMTP-LOGIN as {} ok",
-                            lp.send_user,
-                        )));
-                        return Ok(());
-                    }
-                    Err(err) => {
-                        bail!("SMTP: failed to connect {:?}", err);
-                    }
-                }
-            }
-            Err(err) => {
-                bail!("SMTP: failed to setup connection {:?}", err);
-            }
-        }
-    }
-
-    /// SMTP-Send a prepared mail to recipients.
-    /// on successful send out Ok() is returned.
-    pub fn send(
-        &mut self,
-        context: &Context,
-        recipients: Vec<EmailAddress>,
-        message: Vec<u8>,
-        job_id: u32,
-    ) -> Result<(), Error> {
-        let message_len = message.len();
-
-        let recipients_display = recipients
-            .iter()
-            .map(|x| format!("{}", x))
-            .collect::<Vec<String>>()
-            .join(",");
-
-        if let Some(ref mut transport) = self.transport {
-            let envelope = match Envelope::new(self.from.clone(), recipients) {
-                Ok(env) => env,
-                Err(err) => {
-                    bail!("{}", err);
-                }
-            };
-            let mail = SendableEmail::new(
-                envelope,
-                format!("{}", job_id), // only used for internal logging
-                message,
-            );
-
-            match transport.send(mail) {
-                Ok(_) => {
-                    context.call_cb(Event::SmtpMessageSent(format!(
-                        "Message len={} was smtp-sent to {}",
-                        message_len, recipients_display
-                    )));
-                    self.transport_connected = true;
-                    Ok(())
-                }
-                Err(err) => {
-                    bail!("SMTP failed len={}: error: {}", message_len, err);
-                }
-            }
-        } else {
-            bail!(
-                "uh? SMTP has no transport,  failed to send to {:?}",
-                recipients_display
-            );
-        }
-    }
-}

src/smtp/mod.rs

@@ -0,0 +1,154 @@
+//! # SMTP transport module
+
+pub mod send;
+
+use lettre::smtp::client::net::*;
+use lettre::*;
+
+use failure::Fail;
+
+use crate::constants::*;
+use crate::context::Context;
+use crate::events::Event;
+use crate::login_param::{dc_build_tls_config, LoginParam};
+use crate::oauth2::*;
+
+#[derive(Debug, Fail)]
+pub enum Error {
+    #[fail(display = "Bad parameters")]
+    BadParameters,
+    #[fail(display = "Invalid login address {}: {}", address, error)]
+    InvalidLoginAddress {
+        address: String,
+        #[cause]
+        error: lettre::error::Error,
+    },
+    #[fail(display = "SMTP failed to connect: {:?}", _0)]
+    ConnectionFailure(#[cause] lettre::smtp::error::Error),
+    #[fail(display = "SMTP: failed to setup connection {:?}", _0)]
+    ConnectionSetupFailure(#[cause] lettre::smtp::error::Error),
+    #[fail(display = "SMTP: oauth2 error {:?}", _0)]
+    Oauth2Error { address: String },
+}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+#[derive(DebugStub)]
+pub struct Smtp {
+    #[debug_stub(some = "SmtpTransport")]
+    transport: Option<lettre::smtp::SmtpTransport>,
+    transport_connected: bool,
+    /// Email address we are sending from.
+    from: Option<EmailAddress>,
+}
+
+impl Smtp {
+    /// Create a new Smtp instances.
+    pub fn new() -> Self {
+        Smtp {
+            transport: None,
+            transport_connected: false,
+            from: None,
+        }
+    }
+
+    /// Disconnect the SMTP transport and drop it entirely.
+    pub fn disconnect(&mut self) {
+        if self.transport.is_none() || !self.transport_connected {
+            return;
+        }
+
+        let mut transport = self.transport.take().unwrap();
+        transport.close();
+        self.transport_connected = false;
+    }
+
+    /// Check if a connection already exists.
+    pub fn is_connected(&self) -> bool {
+        self.transport.is_some()
+    }
+
+    /// Connect using the provided login params
+    pub fn connect(&mut self, context: &Context, lp: &LoginParam) -> Result<()> {
+        if self.is_connected() {
+            warn!(context, "SMTP already connected.");
+            return Ok(());
+        }
+
+        if lp.send_server.is_empty() || lp.send_port == 0 {
+            context.call_cb(Event::ErrorNetwork("SMTP bad parameters.".into()));
+            return Err(Error::BadParameters);
+        }
+
+        let from =
+            EmailAddress::new(lp.addr.clone()).map_err(|err| Error::InvalidLoginAddress {
+                address: lp.addr.clone(),
+                error: err,
+            })?;
+        self.from = Some(from);
+
+        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 (creds, mechanism) = if 0 != lp.server_flags & (DC_LP_AUTH_OAUTH2 as i32) {
+            // oauth2
+            let addr = &lp.addr;
+            let send_pw = &lp.send_pw;
+            let access_token = dc_get_oauth2_access_token(context, addr, send_pw, false);
+            if access_token.is_none() {
+                return Err(Error::Oauth2Error {
+                    address: addr.to_string(),
+                });
+            }
+            let user = &lp.send_user;
+            (
+                lettre::smtp::authentication::Credentials::new(
+                    user.to_string(),
+                    access_token.unwrap_or_default(),
+                ),
+                vec![lettre::smtp::authentication::Mechanism::Xoauth2],
+            )
+        } else {
+            // plain
+            let user = lp.send_user.clone();
+            let pw = lp.send_pw.clone();
+            (
+                lettre::smtp::authentication::Credentials::new(user, pw),
+                vec![
+                    lettre::smtp::authentication::Mechanism::Plain,
+                    lettre::smtp::authentication::Mechanism::Login,
+                ],
+            )
+        };
+
+        let security = if 0
+            != lp.server_flags & (DC_LP_SMTP_SOCKET_STARTTLS | DC_LP_SMTP_SOCKET_PLAIN) as i32
+        {
+            lettre::smtp::ClientSecurity::Opportunistic(tls_parameters)
+        } else {
+            lettre::smtp::ClientSecurity::Wrapper(tls_parameters)
+        };
+
+        let client = lettre::smtp::SmtpClient::new((domain.as_str(), port), security)
+            .map_err(Error::ConnectionSetupFailure)?;
+
+        let client = client
+            .smtp_utf8(true)
+            .credentials(creds)
+            .authentication_mechanism(mechanism)
+            .connection_reuse(lettre::smtp::ConnectionReuseParameters::ReuseUnlimited);
+        let mut trans = client.transport();
+        trans.connect().map_err(Error::ConnectionFailure)?;
+
+        self.transport = Some(trans);
+        self.transport_connected = true;
+        context.call_cb(Event::SmtpConnected(format!(
+            "SMTP-LOGIN as {} ok",
+            lp.send_user,
+        )));
+        Ok(())
+    }
+}

src/smtp/send.rs

@@ -0,0 +1,64 @@
+//! # SMTP message sending
+
+use super::Smtp;
+use lettre::*;
+
+use crate::context::Context;
+use crate::events::Event;
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+#[derive(Debug, Fail)]
+pub enum Error {
+    #[fail(display = "Envelope error: {}", _0)]
+    EnvelopeError(#[cause] lettre::error::Error),
+    #[fail(display = "Send error: {}", _0)]
+    SendError(#[cause] lettre::smtp::error::Error),
+    #[fail(display = "SMTP has no transport")]
+    NoTransport,
+}
+
+impl Smtp {
+    /// Send a prepared mail to recipients.
+    /// On successful send out Ok() is returned.
+    pub fn send(
+        &mut self,
+        context: &Context,
+        recipients: Vec<EmailAddress>,
+        message: Vec<u8>,
+        job_id: u32,
+    ) -> Result<()> {
+        let message_len = message.len();
+
+        let recipients_display = recipients
+            .iter()
+            .map(|x| format!("{}", x))
+            .collect::<Vec<String>>()
+            .join(",");
+
+        if let Some(ref mut transport) = self.transport {
+            let envelope =
+                Envelope::new(self.from.clone(), recipients).map_err(Error::EnvelopeError)?;
+            let mail = SendableEmail::new(
+                envelope,
+                format!("{}", job_id), // only used for internal logging
+                message,
+            );
+
+            transport.send(mail).map_err(Error::SendError)?;
+
+            context.call_cb(Event::SmtpMessageSent(format!(
+                "Message len={} was smtp-sent to {}",
+                message_len, recipients_display
+            )));
+            self.transport_connected = true;
+            Ok(())
+        } else {
+            warn!(
+                context,
+                "uh? SMTP has no transport, failed to send to {}", recipients_display
+            );
+            return Err(Error::NoTransport);
+        }
+    }
+}

src/sql.rs

@@ -1,5 +1,7 @@
 //! # SQLite wrapper
 
+use failure::Fail;
+
 use std::collections::HashSet;
 use std::sync::{Arc, RwLock};
 use std::time::Duration;
@@ -11,10 +13,53 @@ use crate::chat::update_saved_messages_icon;
 use crate::constants::ShowEmails;
 use crate::context::Context;
 use crate::dc_tools::*;
-use crate::error::{Error, Result};
 use crate::param::*;
 use crate::peerstate::*;
 
+#[derive(Debug, Fail)]
+pub enum Error {
+    #[fail(display = "Sqlite Error: {:?}", _0)]
+    Sql(#[cause] rusqlite::Error),
+    #[fail(display = "Sqlite Connection Pool Error: {:?}", _0)]
+    ConnectionPool(#[cause] r2d2::Error),
+    #[fail(display = "Sqlite: Connection closed")]
+    SqlNoConnection,
+    #[fail(display = "Sqlite: Already open")]
+    SqlAlreadyOpen,
+    #[fail(display = "Sqlite: Failed to open")]
+    SqlFailedToOpen,
+    #[fail(display = "{:?}", _0)]
+    Io(#[cause] std::io::Error),
+    #[fail(display = "{:?}", _0)]
+    BlobError(#[cause] crate::blob::BlobError),
+}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+impl From<rusqlite::Error> for Error {
+    fn from(err: rusqlite::Error) -> Error {
+        Error::Sql(err)
+    }
+}
+
+impl From<r2d2::Error> for Error {
+    fn from(err: r2d2::Error) -> Error {
+        Error::ConnectionPool(err)
+    }
+}
+
+impl From<std::io::Error> for Error {
+    fn from(err: std::io::Error) -> Error {
+        Error::Io(err)
+    }
+}
+
+impl From<crate::blob::BlobError> for Error {
+    fn from(err: crate::blob::BlobError) -> Error {
+        Error::BlobError(err)
+    }
+}
+
 /// A wrapper around the underlying Sqlite3 object.
 #[derive(DebugStub)]
 pub struct Sql {
@@ -47,7 +92,7 @@ impl Sql {
     pub fn open(&self, context: &Context, dbfile: &std::path::Path, readonly: bool) -> bool {
         match open(context, self, dbfile, readonly) {
             Ok(_) => true,
-            Err(Error::SqlAlreadyOpen) => false,
+            Err(crate::error::Error::SqlError(Error::SqlAlreadyOpen)) => false,
             Err(_) => {
                 self.close(context);
                 false
@@ -321,14 +366,14 @@ fn open(
     sql: &Sql,
     dbfile: impl AsRef<std::path::Path>,
     readonly: bool,
-) -> Result<()> {
+) -> crate::error::Result<()> {
     if sql.is_open() {
         error!(
             context,
             "Cannot open, database \"{:?}\" already opened.",
             dbfile.as_ref(),
         );
-        return Err(Error::SqlAlreadyOpen);
+        return Err(Error::SqlAlreadyOpen.into());
     }
 
     let mut open_flags = OpenFlags::SQLITE_OPEN_NO_MUTEX;
@@ -345,7 +390,8 @@ fn open(
         .min_idle(Some(2))
         .max_size(10)
         .connection_timeout(std::time::Duration::new(60, 0))
-        .build(mgr)?;
+        .build(mgr)
+        .map_err(Error::ConnectionPool)?;
 
     {
         *sql.pool.write().unwrap() = Some(pool);
@@ -477,7 +523,7 @@ fn open(
                     dbfile.as_ref(),
                 );
                 // cannot create the tables - maybe we cannot write?
-                return Err(Error::SqlFailedToOpen);
+                return Err(Error::SqlFailedToOpen.into());
             } else {
                 sql.set_raw_config_int(context, "dbversion", 0)?;
             }
@@ -829,6 +875,14 @@ fn open(
             update_icons = true;
             sql.set_raw_config_int(context, "dbversion", 59)?;
         }
+        if dbversion < 60 {
+            info!(context, "[migration] v60");
+            sql.execute(
+                "ALTER TABLE chats ADD COLUMN created_timestamp INTEGER DEFAULT 0;",
+                NO_PARAMS,
+            )?;
+            sql.set_raw_config_int(context, "dbversion", 60)?;
+        }
 
         // (2) updates that require high-level objects
         // (the structure is complete now and all objects are usable)

src/stock.rs

@@ -5,9 +5,13 @@ use std::borrow::Cow;
 use strum::EnumProperty;
 use strum_macros::EnumProperty;
 
+use crate::chat;
+use crate::constants::{Viewtype, DC_CONTACT_ID_SELF};
 use crate::contact::*;
 use crate::context::Context;
 use crate::error::Error;
+use crate::message::Message;
+use crate::stock::StockMessage::{DeviceMessagesHint, WelcomeMessage};
 
 /// Stock strings
 ///
@@ -22,102 +26,169 @@ use crate::error::Error;
 pub enum StockMessage {
     #[strum(props(fallback = "No messages."))]
     NoMessages = 1,
+
     #[strum(props(fallback = "Me"))]
     SelfMsg = 2,
+
     #[strum(props(fallback = "Draft"))]
     Draft = 3,
+
     #[strum(props(fallback = "%1$s member(s)"))]
     Member = 4,
+
     #[strum(props(fallback = "%1$s contact(s)"))]
     Contact = 6,
+
     #[strum(props(fallback = "Voice message"))]
     VoiceMessage = 7,
+
     #[strum(props(fallback = "Contact requests"))]
     DeadDrop = 8,
+
     #[strum(props(fallback = "Image"))]
     Image = 9,
+
     #[strum(props(fallback = "Video"))]
     Video = 10,
+
     #[strum(props(fallback = "Audio"))]
     Audio = 11,
+
     #[strum(props(fallback = "File"))]
     File = 12,
+
     #[strum(props(fallback = "Sent with my Delta Chat Messenger: https://delta.chat"))]
     StatusLine = 13,
+
     #[strum(props(fallback = "Hello, I\'ve just created the group \"%1$s\" for us."))]
     NewGroupDraft = 14,
+
     #[strum(props(fallback = "Group name changed from \"%1$s\" to \"%2$s\"."))]
     MsgGrpName = 15,
+
     #[strum(props(fallback = "Group image changed."))]
     MsgGrpImgChanged = 16,
+
     #[strum(props(fallback = "Member %1$s added."))]
     MsgAddMember = 17,
+
     #[strum(props(fallback = "Member %1$s removed."))]
     MsgDelMember = 18,
+
     #[strum(props(fallback = "Group left."))]
     MsgGroupLeft = 19,
+
     #[strum(props(fallback = "GIF"))]
     Gif = 23,
+
     #[strum(props(fallback = "Encrypted message"))]
     EncryptedMsg = 24,
+
     #[strum(props(fallback = "End-to-end encryption available."))]
     E2eAvailable = 25,
+
     #[strum(props(fallback = "Transport-encryption."))]
     EncrTransp = 27,
+
     #[strum(props(fallback = "No encryption."))]
     EncrNone = 28,
+
     #[strum(props(fallback = "This message was encrypted for another setup."))]
     CantDecryptMsgBody = 29,
+
     #[strum(props(fallback = "Fingerprints"))]
     FingerPrints = 30,
+
     #[strum(props(fallback = "Return receipt"))]
     ReadRcpt = 31,
+
     #[strum(props(fallback = "This is a return receipt for the message \"%1$s\"."))]
     ReadRcptMailBody = 32,
+
     #[strum(props(fallback = "Group image deleted."))]
     MsgGrpImgDeleted = 33,
+
     #[strum(props(fallback = "End-to-end encryption preferred."))]
     E2ePreferred = 34,
+
     #[strum(props(fallback = "%1$s verified."))]
     ContactVerified = 35,
+
     #[strum(props(fallback = "Cannot verify %1$s"))]
     ContactNotVerified = 36,
+
     #[strum(props(fallback = "Changed setup for %1$s"))]
     ContactSetupChanged = 37,
+
     #[strum(props(fallback = "Archived chats"))]
     ArchivedChats = 40,
+
     #[strum(props(fallback = "Starred messages"))]
     StarredMsgs = 41,
+
     #[strum(props(fallback = "Autocrypt Setup Message"))]
     AcSetupMsgSubject = 42,
+
     #[strum(props(
         fallback = "This is the Autocrypt Setup Message used to transfer your key between clients.\n\nTo decrypt and use your key, open the message in an Autocrypt-compliant client and enter the setup code presented on the generating device."
     ))]
     AcSetupMsgBody = 43,
+
     #[strum(props(fallback = "Messages I sent to myself"))]
     SelfTalkSubTitle = 50,
+
     #[strum(props(fallback = "Cannot login as %1$s."))]
     CannotLogin = 60,
+
     #[strum(props(fallback = "Could not connect to %1$s: %2$s"))]
     ServerResponse = 61,
+
     #[strum(props(fallback = "%1$s by %2$s."))]
     MsgActionByUser = 62,
+
     #[strum(props(fallback = "%1$s by me."))]
     MsgActionByMe = 63,
+
     #[strum(props(fallback = "Location streaming enabled."))]
     MsgLocationEnabled = 64,
+
     #[strum(props(fallback = "Location streaming disabled."))]
     MsgLocationDisabled = 65,
+
     #[strum(props(fallback = "Location"))]
     Location = 66,
+
     #[strum(props(fallback = "Sticker"))]
     Sticker = 67,
+
     #[strum(props(fallback = "Device messages"))]
     DeviceMessages = 68,
+
     #[strum(props(fallback = "Saved messages"))]
     SavedMessages = 69,
+
+    #[strum(props(
+        fallback = "Messages in this chat are generated locally by your Delta Chat app. \
+                    Its makers use it to inform about app updates and problems during usage."
+    ))]
+    DeviceMessagesHint = 70,
+
+    #[strum(props(fallback = "Welcome to Delta Chat! – \
+                    Delta Chat looks and feels like other popular messenger apps, \
+                    but does not involve centralized control, \
+                    tracking or selling you, friends, colleagues or family out to large organizations.\n\n\
+                    Technically, Delta Chat is an email application with a modern chat interface. \
+                    Email in a new dress if you will 👻\n\n\
+                    Use Delta Chat with anyone out of billions of people: just use their e-mail address. \
+                    Recipients don't need to install Delta Chat, visit websites or sign up anywhere - \
+                    however, of course, if they like, you may point them to 👉 https://get.delta.chat"))]
+    WelcomeMessage = 71,
 }
 
+/*
+"
+*/
+
 impl StockMessage {
     /// Default untranslated strings for stock messages.
     ///
@@ -264,6 +335,27 @@ impl Context {
             }
         }
     }
+
+    pub fn update_device_chats(&self) -> Result<(), Error> {
+        // create saved-messages chat;
+        // we do this only once, if the user has deleted the chat, he can recreate it manually.
+        if !self.sql.get_raw_config_bool(&self, "self-chat-added") {
+            self.sql
+                .set_raw_config_bool(&self, "self-chat-added", true)?;
+            chat::create_by_contact_id(&self, DC_CONTACT_ID_SELF)?;
+        }
+
+        // add welcome-messages. by the label, this is done only once,
+        // if the user has deleted the message or the chat, it is not added again.
+        let mut msg = Message::new(Viewtype::Text);
+        msg.text = Some(self.stock_str(DeviceMessagesHint).to_string());
+        chat::add_device_msg(&self, Some("core-about-device-chat"), Some(&mut msg))?;
+
+        let mut msg = Message::new(Viewtype::Text);
+        msg.text = Some(self.stock_str(WelcomeMessage).to_string());
+        chat::add_device_msg(&self, Some("core-welcome"), Some(&mut msg))?;
+        Ok(())
+    }
 }
 
 #[cfg(test)]
@@ -273,6 +365,7 @@ mod tests {
 
     use crate::constants::DC_CONTACT_ID_SELF;
 
+    use crate::chatlist::Chatlist;
     use num_traits::ToPrimitive;
 
     #[test]
@@ -428,4 +521,22 @@ mod tests {
             "Group name changed from \"Some chat\" to \"Other chat\" by Alice (alice@example.com)."
         )
     }
+
+    #[test]
+    fn test_update_device_chats() {
+        let t = dummy_context();
+        t.ctx.update_device_chats().ok();
+        let chats = Chatlist::try_load(&t.ctx, 0, None, None).unwrap();
+        assert_eq!(chats.len(), 2);
+
+        chat::delete(&t.ctx, chats.get_chat_id(0)).ok();
+        chat::delete(&t.ctx, chats.get_chat_id(1)).ok();
+        let chats = Chatlist::try_load(&t.ctx, 0, None, None).unwrap();
+        assert_eq!(chats.len(), 0);
+
+        // a subsequent call to update_device_chats() must not re-add manally deleted messages or chats
+        t.ctx.update_device_chats().ok();
+        let chats = Chatlist::try_load(&t.ctx, 0, None, None).unwrap();
+        assert_eq!(chats.len(), 0);
+    }
 }

src/test_utils.rs

@@ -7,7 +7,7 @@ use tempfile::{tempdir, TempDir};
 
 use crate::config::Config;
 use crate::constants::KeyType;
-use crate::context::{Context, ContextBuilder, ContextCallback};
+use crate::context::{Context, ContextCallback};
 use crate::events::Event;
 use crate::key;
 
@@ -33,9 +33,7 @@ pub fn test_context(callback: Option<Box<ContextCallback>>) -> TestContext {
         Some(cb) => cb,
         None => Box::new(|_, _| 0),
     };
-    let ctx = ContextBuilder::new(cb, "FakeOs".into(), dbfile)
-        .create()
-        .unwrap();
+    let ctx = Context::new(cb, "FakeOs".into(), dbfile).unwrap();
     TestContext { ctx: ctx, dir: dir }
 }
 

src/wrapmime.rs

@@ -1,552 +1,50 @@
-use std::collections::HashSet;
-use std::ffi::CString;
-use std::ptr;
+use mailparse::ParsedMail;
 
-use crate::contact::addr_normalize;
-use crate::dc_strencode::*;
-use crate::dc_tools::*;
 use crate::error::Error;
-use mmime::clist::*;
-// use mmime::display::*;
-use mmime::mailimf::mailimf_msg_id_parse;
-use mmime::mailimf::types::*;
-use mmime::mailimf::types_helper::*;
-use mmime::mailmime::content::*;
-use mmime::mailmime::disposition::*;
-use mmime::mailmime::types::*;
-use mmime::mailmime::types_helper::*;
-use mmime::mailmime::*;
-use mmime::mmapstring::*;
-use mmime::other::*;
-
-#[macro_export]
-macro_rules! clist_append {
-    ($clist:expr,  $item:expr) => {
-        if clist_insert_after(
-            $clist as *mut clist,
-            (*$clist).last,
-            $item as *mut libc::c_void,
-        ) != 0
-        {
-            bail!("could not allocate or append list item");
-        }
-    };
-}
-
-/**************************************
-* mime parsing API
-**************************************/
-
-pub fn get_ct_subtype(mime: *mut Mailmime) -> Option<String> {
-    unsafe {
-        let ct: *mut mailmime_content = (*mime).mm_content_type;
-
-        if !ct.is_null() && !(*ct).ct_subtype.is_null() {
-            Some(to_string_lossy((*ct).ct_subtype))
-        } else {
-            None
-        }
-    }
-}
 
 pub fn parse_message_id(message_id: &[u8]) -> Result<String, Error> {
-    let mut dummy = 0;
-    let mut rfc724_mid_c = std::ptr::null_mut();
-    if unsafe {
-        mailimf_msg_id_parse(
-            message_id.as_ptr() as *const libc::c_char,
-            message_id.len(),
-            &mut dummy,
-            &mut rfc724_mid_c,
-        )
-    } == MAIL_NO_ERROR as libc::c_int
-        && !rfc724_mid_c.is_null()
-    {
-        let res = to_string_lossy(rfc724_mid_c);
-        unsafe { libc::free(rfc724_mid_c.cast()) };
-        Ok(res)
-    } else {
-        bail!(
-            "could not parse message_id: {}",
-            String::from_utf8_lossy(message_id)
-        );
+    let value = std::str::from_utf8(message_id)?;
+    let addrs = mailparse::addrparse(value)
+        .map_err(|err| format_err!("failed to parse message id {:?}", err))?;
+
+    if let Some(info) = addrs.extract_single_info() {
+        return Ok(info.addr);
     }
+
+    bail!("could not parse message_id: {}", value);
 }
 
-pub fn get_autocrypt_mime(
-    mime_undetermined: *mut Mailmime,
-) -> Result<(*mut Mailmime, *mut Mailmime), Error> {
-    /* return Result with two mime pointers:
+/// Returns a reference to the encrypted payload and validates the autocrypt structure.
+pub fn get_autocrypt_mime<'a, 'b>(mail: &'a ParsedMail<'b>) -> Result<&'a ParsedMail<'b>, Error> {
+    ensure!(
+        mail.ctype.mimetype == "multipart/encrypted",
+        "Not a multipart/encrypted message: {}",
+        mail.ctype.mimetype
+    );
+    ensure!(
+        mail.subparts.len() == 2,
+        "Invalid Autocrypt Level 1 Mime Parts"
+    );
 
-    First mime pointer is to the multipart-mime message
-    (which is replaced with a decrypted version later)
+    ensure!(
+        mail.subparts[0].ctype.mimetype == "application/pgp-encrypted",
+        "Invalid Autocrypt Level 1 version part: {:?}",
+        mail.subparts[0].ctype,
+    );
 
-    Second one is to the encrypted payload.
-    For non-autocrypt message an Error is returned.
-    */
-    unsafe {
-        ensure!(
-            (*mime_undetermined).mm_type == MAILMIME_MESSAGE as libc::c_int,
-            "Not a root mime message"
-        );
-        let mime = (*mime_undetermined).mm_data.mm_message.mm_msg_mime;
+    ensure!(
+        mail.subparts[1].ctype.mimetype == "application/octet-stream",
+        "Invalid Autocrypt Level 1 encrypted part: {:?}",
+        mail.subparts[1].ctype
+    );
 
-        ensure!(
-            (*mime).mm_type == MAILMIME_MULTIPLE as libc::c_int
-                && "encrypted" == get_ct_subtype(mime).unwrap_or_default(),
-            "Not a multipart/encrypted message"
-        );
-        let parts: Vec<_> = (*(*mime).mm_data.mm_multipart.mm_mp_list)
-            .into_iter()
-            .map(|c| c as *mut Mailmime)
-            .collect();
-        ensure!(parts.len() == 2, "Invalid Autocrypt Level 1 Mime Parts");
-        // XXX ensure protocol-parameter "application/pgp-encrypted")
-        // XXX ensure wrapmime::get_content_type(parts[1])) == "application/octetstream"
-        // a proper OpenPGP multipart/encrypted Autocrypt Level 1 message
-        // https://tools.ietf.org/html/rfc3156.html#section-4
-        Ok((mime, parts[1]))
-    }
-}
-
-pub fn has_decryptable_data(mime_data: *mut mailmime_data) -> bool {
-    /* MAILMIME_DATA_FILE indicates, the data is in a file; AFAIK this is not used on parsing */
-    unsafe {
-        (*mime_data).dt_type == MAILMIME_DATA_TEXT as libc::c_int
-            && !(*mime_data).dt_data.dt_text.dt_data.is_null()
-            && (*mime_data).dt_data.dt_text.dt_length > 0
-    }
-}
-
-pub fn get_field_from(imffields: *mut mailimf_fields) -> Result<String, Error> {
-    let field = mailimf_find_field(imffields, MAILIMF_FIELD_FROM as libc::c_int);
-    if !field.is_null() && unsafe { !(*field).fld_data.fld_from.is_null() } {
-        let mb_list = unsafe { (*(*field).fld_data.fld_from).frm_mb_list };
-        if let Some(addr) = mailimf_find_first_addr(mb_list) {
-            return Ok(addr);
-        }
-    }
-    bail!("not From field found");
-}
-
-pub fn get_field_date(imffields: *mut mailimf_fields) -> Result<i64, Error> {
-    let field = mailimf_find_field(imffields, MAILIMF_FIELD_ORIG_DATE as libc::c_int);
-    let mut message_time = 0;
-
-    if !field.is_null() && unsafe { !(*field).fld_data.fld_orig_date.is_null() } {
-        let orig_date = unsafe { (*field).fld_data.fld_orig_date };
-
-        if !orig_date.is_null() {
-            let dt = unsafe { (*orig_date).dt_date_time };
-            message_time = dc_timestamp_from_date(dt);
-            if message_time != 0 && message_time > time() {
-                message_time = time()
-            }
-        }
-    }
-
-    Ok(message_time)
-}
-
-fn mailimf_get_recipients_add_addr(recipients: &mut HashSet<String>, mb: *mut mailimf_mailbox) {
-    if !mb.is_null() {
-        let addr = to_string_lossy(unsafe { (*mb).mb_addr_spec });
-        let addr_norm = addr_normalize(&addr);
-        recipients.insert(addr_norm.into());
-    }
-}
-
-/*the result is a pointer to mime, must not be freed*/
-pub fn mailimf_find_field(
-    header: *mut mailimf_fields,
-    wanted_fld_type: libc::c_int,
-) -> *mut mailimf_field {
-    if header.is_null() {
-        return ptr::null_mut();
-    }
-
-    let header = unsafe { (*header) };
-    if header.fld_list.is_null() {
-        return ptr::null_mut();
-    }
-
-    for cur in unsafe { &(*header.fld_list) } {
-        let field = cur as *mut mailimf_field;
-        if !field.is_null() {
-            if unsafe { (*field).fld_type } == wanted_fld_type {
-                return field;
-            }
-        }
-    }
-
-    ptr::null_mut()
-}
-
-/*the result is a pointer to mime, must not be freed*/
-pub fn mailmime_find_mailimf_fields(mime: *mut Mailmime) -> *mut mailimf_fields {
-    if mime.is_null() {
-        return ptr::null_mut();
-    }
-
-    match unsafe { (*mime).mm_type as _ } {
-        MAILMIME_MULTIPLE => {
-            for cur_data in unsafe { (*(*mime).mm_data.mm_multipart.mm_mp_list).into_iter() } {
-                let header = mailmime_find_mailimf_fields(cur_data as *mut _);
-                if !header.is_null() {
-                    return header;
-                }
-            }
-        }
-        MAILMIME_MESSAGE => return unsafe { (*mime).mm_data.mm_message.mm_fields },
-        _ => {}
-    }
-
-    ptr::null_mut()
-}
-
-pub unsafe fn mailimf_find_optional_field(
-    header: *mut mailimf_fields,
-    wanted_fld_name: *const libc::c_char,
-) -> *mut mailimf_optional_field {
-    if header.is_null() || (*header).fld_list.is_null() {
-        return ptr::null_mut();
-    }
-    for cur_data in (*(*header).fld_list).into_iter() {
-        let field: *mut mailimf_field = cur_data as *mut _;
-
-        if (*field).fld_type == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int {
-            let optional_field: *mut mailimf_optional_field = (*field).fld_data.fld_optional_field;
-            if !optional_field.is_null()
-                && !(*optional_field).fld_name.is_null()
-                && !(*optional_field).fld_value.is_null()
-                && strcasecmp((*optional_field).fld_name, wanted_fld_name) == 0i32
-            {
-                return optional_field;
-            }
-        }
-    }
-
-    ptr::null_mut()
-}
-
-pub fn mailimf_get_recipients(imffields: *mut mailimf_fields) -> HashSet<String> {
-    /* returned addresses are normalized. */
-    let mut recipients: HashSet<String> = Default::default();
-
-    for cur in unsafe { (*(*imffields).fld_list).into_iter() } {
-        let fld = cur as *mut mailimf_field;
-
-        let fld_to: *mut mailimf_to;
-        let fld_cc: *mut mailimf_cc;
-
-        let mut addr_list: *mut mailimf_address_list = ptr::null_mut();
-        if fld.is_null() {
-            continue;
-        }
-
-        let fld = unsafe { *fld };
-
-        // TODO match on enums /rtn
-        match fld.fld_type {
-            13 => {
-                fld_to = unsafe { fld.fld_data.fld_to };
-                if !fld_to.is_null() {
-                    addr_list = unsafe { (*fld_to).to_addr_list };
-                }
-            }
-            14 => {
-                fld_cc = unsafe { fld.fld_data.fld_cc };
-                if !fld_cc.is_null() {
-                    addr_list = unsafe { (*fld_cc).cc_addr_list };
-                }
-            }
-            _ => {}
-        }
-
-        if !addr_list.is_null() {
-            for cur2 in unsafe { &(*(*addr_list).ad_list) } {
-                let adr = cur2 as *mut mailimf_address;
-
-                if adr.is_null() {
-                    continue;
-                }
-                let adr = unsafe { *adr };
-
-                if adr.ad_type == MAILIMF_ADDRESS_MAILBOX as libc::c_int {
-                    mailimf_get_recipients_add_addr(&mut recipients, unsafe {
-                        adr.ad_data.ad_mailbox
-                    });
-                } else if adr.ad_type == MAILIMF_ADDRESS_GROUP as libc::c_int {
-                    let group = unsafe { adr.ad_data.ad_group };
-                    if !group.is_null() && unsafe { !(*group).grp_mb_list.is_null() } {
-                        for cur3 in unsafe { &(*(*(*group).grp_mb_list).mb_list) } {
-                            mailimf_get_recipients_add_addr(
-                                &mut recipients,
-                                cur3 as *mut mailimf_mailbox,
-                            );
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    recipients
-}
-
-pub fn mailmime_transfer_decode(mime: *mut Mailmime) -> Result<Vec<u8>, Error> {
-    ensure!(!mime.is_null(), "invalid inputs");
-
-    let mime_transfer_encoding =
-        get_mime_transfer_encoding(mime).unwrap_or(MAILMIME_MECHANISM_BINARY as i32);
-
-    let mime_data = unsafe { (*mime).mm_data.mm_single };
-
-    decode_dt_data(mime_data, mime_transfer_encoding)
-}
-
-pub fn get_mime_transfer_encoding(mime: *mut Mailmime) -> Option<libc::c_int> {
-    unsafe {
-        let mm_mime_fields = (*mime).mm_mime_fields;
-        if !mm_mime_fields.is_null() {
-            for cur_data in (*(*mm_mime_fields).fld_list).into_iter() {
-                let field: *mut mailmime_field = cur_data as *mut _;
-                if (*field).fld_type == MAILMIME_FIELD_TRANSFER_ENCODING as libc::c_int
-                    && !(*field).fld_data.fld_encoding.is_null()
-                {
-                    return Some((*(*field).fld_data.fld_encoding).enc_type);
-                }
-            }
-        }
-    }
-    None
-}
-
-pub fn decode_dt_data(
-    mime_data: *mut mailmime_data,
-    mime_transfer_encoding: libc::c_int,
-) -> Result<Vec<u8>, Error> {
-    // Decode data according to mime_transfer_encoding
-    // returns Ok with a (decoded_data,decoded_data_bytes) pointer
-    // where the caller must make sure to free it.
-    // It may return Ok(ptr::null_mut(), 0)
-    if mime_transfer_encoding == MAILMIME_MECHANISM_7BIT as libc::c_int
-        || mime_transfer_encoding == MAILMIME_MECHANISM_8BIT as libc::c_int
-        || mime_transfer_encoding == MAILMIME_MECHANISM_BINARY as libc::c_int
-    {
-        let decoded_data = unsafe { (*mime_data).dt_data.dt_text.dt_data };
-        let decoded_data_bytes = unsafe { (*mime_data).dt_data.dt_text.dt_length };
-
-        if decoded_data.is_null() || decoded_data_bytes == 0 {
-            bail!("No data to decode found");
-        } else {
-            let result = unsafe {
-                std::slice::from_raw_parts(decoded_data as *const u8, decoded_data_bytes)
-            };
-            return Ok(result.to_vec());
-        }
-    }
-    // unsafe { display_mime_data(mime_data) };
-
-    let mut current_index = 0;
-    let mut transfer_decoding_buffer = ptr::null_mut();
-    let mut decoded_data_bytes = 0;
-
-    let r = unsafe {
-        mailmime_part_parse(
-            (*mime_data).dt_data.dt_text.dt_data,
-            (*mime_data).dt_data.dt_text.dt_length,
-            &mut current_index,
-            mime_transfer_encoding,
-            &mut transfer_decoding_buffer,
-            &mut decoded_data_bytes,
-        )
-    };
-
-    if r == MAILIMF_NO_ERROR as libc::c_int
-        && !transfer_decoding_buffer.is_null()
-        && decoded_data_bytes > 0
-    {
-        let result = unsafe {
-            std::slice::from_raw_parts(transfer_decoding_buffer as *const u8, decoded_data_bytes)
-        }
-        .to_vec();
-        // we return a fresh vec and transfer_decoding_buffer is not used or passed anywhere
-        // so it's safe to free it right away, as mailman_part_parse has
-        // allocated it fresh.
-        unsafe { mmap_string_unref(transfer_decoding_buffer) };
-
-        return Ok(result);
-    }
-
-    Err(format_err!("Failed to to decode"))
-}
-
-pub fn mailimf_find_first_addr(mb_list: *const mailimf_mailbox_list) -> Option<String> {
-    if mb_list.is_null() {
-        return None;
-    }
-
-    for cur in unsafe { (*(*mb_list).mb_list).into_iter() } {
-        let mb = cur as *mut mailimf_mailbox;
-        if !mb.is_null() && !unsafe { (*mb).mb_addr_spec.is_null() } {
-            let addr = unsafe { to_string_lossy((*mb).mb_addr_spec) };
-            return Some(addr_normalize(&addr).to_string());
-        }
-    }
-
-    None
-}
-
-/**************************************
-* mime creation API
-**************************************/
-
-pub fn add_filename_part(
-    message: *mut Mailmime,
-    basename: &str,
-    mime_type: &str,
-    file_content: &str,
-) -> Result<(), Error> {
-    let mime_type_c = CString::new(mime_type.to_string()).expect("failed to create CString");
-    unsafe {
-        let content_type = mailmime_content_new_with_str(mime_type_c.as_ptr());
-        let mime_fields = mailmime_fields_new_filename(
-            MAILMIME_DISPOSITION_TYPE_ATTACHMENT as libc::c_int,
-            basename.strdup(),
-            MAILMIME_MECHANISM_8BIT as libc::c_int,
-        );
-        let file_mime_part = mailmime_new_empty(content_type, mime_fields);
-        set_body_text(file_mime_part, file_content)?;
-        mailmime_smart_add_part(message, file_mime_part);
-    }
-    Ok(())
-}
-
-pub fn new_custom_field(fields: *mut mailimf_fields, name: &str, value: &str) {
-    unsafe {
-        let field = mailimf_field_new_custom(name.strdup(), value.strdup());
-        let res = mailimf_fields_add(fields, field);
-        assert!(
-            res as u32 == MAILIMF_NO_ERROR,
-            "could not create mailimf field"
-        );
-    }
-}
-
-pub fn build_body_text(text: &str) -> Result<*mut Mailmime, Error> {
-    let mime_fields: *mut mailmime_fields;
-    let message_part: *mut Mailmime;
-
-    let content = new_content_type("text/plain")?;
-    append_ct_param(content, "charset", "utf-8")?;
-
-    unsafe {
-        mime_fields = mailmime_fields_new_encoding(MAILMIME_MECHANISM_8BIT as libc::c_int);
-        message_part = mailmime_new_empty(content, mime_fields);
-    }
-    set_body_text(message_part, text)?;
-
-    Ok(message_part)
-}
-
-pub fn append_ct_param(
-    content: *mut mailmime_content,
-    name: &str,
-    value: &str,
-) -> Result<(), Error> {
-    unsafe {
-        let name_c = CString::new(name).unwrap_or_default();
-        let value_c = CString::new(value).unwrap_or_default();
-
-        clist_append!(
-            (*content).ct_parameters,
-            mailmime_param_new_with_data(
-                name_c.as_ptr() as *const u8 as *const libc::c_char as *mut libc::c_char,
-                value_c.as_ptr() as *const u8 as *const libc::c_char as *mut libc::c_char
-            )
-        );
-    }
-    Ok(())
-}
-
-pub fn new_content_type(content_type: &str) -> Result<*mut mailmime_content, Error> {
-    let ct = CString::new(content_type).unwrap_or_default();
-    let content: *mut mailmime_content;
-    // mailmime_content_new_with_str only parses but does not retain/own ct
-    unsafe {
-        content = mailmime_content_new_with_str(ct.as_ptr());
-    }
-    ensure!(!content.is_null(), "mailimf failed to allocate");
-    Ok(content)
-}
-
-pub fn set_body_text(part: *mut Mailmime, text: &str) -> Result<(), Error> {
-    use libc::strlen;
-    unsafe {
-        let text_c = text.strdup();
-        if 0 != mailmime_set_body_text(part, text_c, strlen(text_c)) {
-            bail!("could not set body text on mime-structure");
-        }
-    }
-    Ok(())
-}
-
-pub fn content_type_needs_encoding(content: *const mailmime_content) -> bool {
-    unsafe {
-        if (*(*content).ct_type).tp_type == MAILMIME_TYPE_COMPOSITE_TYPE as libc::c_int {
-            let composite = (*(*content).ct_type).tp_data.tp_composite_type;
-            match (*composite).ct_type as u32 {
-                MAILMIME_COMPOSITE_TYPE_MESSAGE => {
-                    to_string_lossy((*content).ct_subtype) != "rfc822"
-                }
-                MAILMIME_COMPOSITE_TYPE_MULTIPART => false,
-                _ => false,
-            }
-        } else {
-            true
-        }
-    }
-}
-
-pub fn new_mailbox_list(displayname: &str, addr: &str) -> *mut mailimf_mailbox_list {
-    let mbox: *mut mailimf_mailbox_list = unsafe { mailimf_mailbox_list_new_empty() };
-    unsafe {
-        mailimf_mailbox_list_add(
-            mbox,
-            mailimf_mailbox_new(
-                if !displayname.is_empty() {
-                    dc_encode_header_words(&displayname).strdup()
-                } else {
-                    ptr::null_mut()
-                },
-                addr.strdup(),
-            ),
-        );
-    }
-    mbox
+    Ok(&mail.subparts[1])
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    #[test]
-    fn test_needs_encoding() {
-        assert!(content_type_needs_encoding(
-            new_content_type("text/plain").unwrap()
-        ));
-        assert!(content_type_needs_encoding(
-            new_content_type("application/octect-stream").unwrap()
-        ));
-        assert!(!content_type_needs_encoding(
-            new_content_type("multipart/encrypted").unwrap()
-        ));
-        assert!(content_type_needs_encoding(
-            new_content_type("application/pgp-encrypted").unwrap()
-        ));
-    }
-
     #[test]
     fn test_parse_message_id() {
         assert_eq!(

tests/stress.rs

@@ -7,7 +7,6 @@ use deltachat::config;
 use deltachat::contact::*;
 use deltachat::context::*;
 use deltachat::keyring::*;
-use deltachat::oauth2::*;
 use deltachat::pgp;
 use deltachat::Event;
 use tempfile::{tempdir, TempDir};
@@ -15,7 +14,7 @@ use tempfile::{tempdir, TempDir};
 /* some data used for testing
  ******************************************************************************/
 
-unsafe fn stress_functions(context: &Context) {
+fn stress_functions(context: &Context) {
     let res = context.get_config(config::Config::SysConfigKeys).unwrap();
 
     assert!(!res.contains(" probably_never_a_key "));
@@ -219,48 +218,14 @@ struct TestContext {
 fn create_test_context() -> TestContext {
     let dir = tempdir().unwrap();
     let dbfile = dir.path().join("db.sqlite");
-    let ctx = ContextBuilder::new(Box::new(cb), "FakeOs".into(), dbfile)
-        .create()
-        .unwrap();
+    let ctx = Context::new(Box::new(cb), "FakeOs".into(), dbfile).unwrap();
     TestContext { ctx, dir }
 }
 
-#[test]
-fn test_dc_get_oauth2_url() {
-    let ctx = create_test_context();
-    let addr = "dignifiedquire@gmail.com";
-    let redirect_uri = "chat.delta:/com.b44t.messenger";
-    let res = dc_get_oauth2_url(&ctx.ctx, addr, redirect_uri);
-
-    assert_eq!(res, Some("https://accounts.google.com/o/oauth2/auth?client_id=959970109878%2D4mvtgf6feshskf7695nfln6002mom908%2Eapps%2Egoogleusercontent%2Ecom&redirect_uri=chat%2Edelta%3A%2Fcom%2Eb44t%2Emessenger&response_type=code&scope=https%3A%2F%2Fmail.google.com%2F%20email&access_type=offline".into()));
-}
-
-#[test]
-fn test_dc_get_oauth2_addr() {
-    let ctx = create_test_context();
-    let addr = "dignifiedquire@gmail.com";
-    let code = "fail";
-    let res = dc_get_oauth2_addr(&ctx.ctx, addr, code);
-    // this should fail as it is an invalid password
-    assert_eq!(res, None);
-}
-
-#[test]
-fn test_dc_get_oauth2_token() {
-    let ctx = create_test_context();
-    let addr = "dignifiedquire@gmail.com";
-    let code = "fail";
-    let res = dc_get_oauth2_access_token(&ctx.ctx, addr, code, false);
-    // this should fail as it is an invalid password
-    assert_eq!(res, None);
-}
-
 #[test]
 fn test_stress_tests() {
-    unsafe {
-        let context = create_test_context();
-        stress_functions(&context.ctx);
-    }
+    let context = create_test_context();
+    stress_functions(&context.ctx);
 }
 
 #[test]