refactor(mmime): split up into modules

mmime/src/constants.rs

@@ -0,0 +1,71 @@
+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/lib.rs

@@ -20,17 +20,7 @@ pub mod charconv;
 pub mod chash;
 pub mod clist;
 pub mod mailimf;
-pub mod mailimf_types;
-pub mod mailimf_types_helper;
-pub mod mailimf_write_generic;
 pub mod mailmime;
-pub mod mailmime_content;
-pub mod mailmime_decode;
-pub mod mailmime_disposition;
-pub mod mailmime_types;
-pub mod mailmime_types_helper;
-pub mod mailmime_write_generic;
-pub mod mailmime_write_mem;
 pub mod mmapstring;
 pub mod other;
 
@@ -38,24 +28,16 @@ pub use self::charconv::*;
 pub use self::chash::*;
 pub use self::clist::*;
 pub use self::mailimf::*;
-pub use self::mailimf_types::*;
-pub use self::mailimf_types_helper::*;
-pub use self::mailimf_write_generic::*;
 pub use self::mailmime::*;
-pub use self::mailmime_content::*;
-pub use self::mailmime_decode::*;
-pub use self::mailmime_disposition::*;
-pub use self::mailmime_types::*;
-pub use self::mailmime_types_helper::*;
-pub use self::mailmime_write_generic::*;
-pub use self::mailmime_write_mem::*;
 pub use self::mmapstring::*;
 pub use self::other::*;
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::mailmime_types::{mailmime, mailmime_content, mailmime_disposition};
+    use crate::mailimf::types::*;
+    use crate::mailmime::types::*;
+
     use std::ffi::CStr;
 
     #[test]
@@ -80,7 +62,7 @@ mod tests {
 
             let mut current_index = 0;
             let mut mime = std::ptr::null_mut();
-            let res = crate::mailmime_content::mailmime_parse(
+            let res = crate::mailmime::content::mailmime_parse(
                 c_data.as_ptr(),
                 data.len() as usize,
                 &mut current_index,
@@ -92,11 +74,11 @@ mod tests {
 
             display_mime(mime);
 
-            mailmime_types::mailmime_free(mime);
+            mailmime::types::mailmime_free(mime);
         }
     }
 
-    unsafe fn display_mime(mut mime: *mut mailmime) {
+    unsafe fn display_mime(mut mime: *mut Mailmime) {
         let mut cur: *mut clistiter = 0 as *mut clistiter;
         println!("{}", (*mime).mm_type);
 
@@ -130,7 +112,7 @@ mod tests {
                             (*cur).data
                         } else {
                             0 as *mut libc::c_void
-                        }) as *mut mailmime,
+                        }) as *mut Mailmime,
                     );
                     cur = if !cur.is_null() {
                         (*cur).next

mmime/src/mailimf/mod.rs

@@ -1,10 +1,13 @@
-use libc;
+pub mod types;
-use libc::toupper;
+pub mod types_helper;
+pub(crate) mod write_generic;
+
+use libc::{self, toupper};
 
 use crate::clist::*;
-use crate::mailimf_types::*;
+use crate::mailimf::types::*;
-use crate::mailmime_decode::*;
+use crate::mailmime::decode::*;
-use crate::mailmime_types::*;
+use crate::mailmime::types::*;
 use crate::mmapstring::*;
 use crate::other::*;
 

mmime/src/mailimf/types_helper.rs

@@ -1,5 +1,5 @@
 use crate::clist::*;
-use crate::mailimf_types::*;
+use crate::mailimf::types::*;
 use crate::other::*;
 
 /*

mmime/src/mailimf/write_generic.rs

@@ -1,5 +1,5 @@
 use crate::clist::*;
-use crate::mailimf_types::*;
+use crate::mailimf::types::*;
 use crate::other::*;
 
 pub const STATE_WORD: libc::c_uint = 1;
@@ -1983,43 +1983,3 @@ unsafe fn mailimf_path_write_driver(
     }
     return MAILIMF_NO_ERROR as libc::c_int;
 }
-/*
-  mailimf_envelope_fields_write writes only some fields to a given stream
-
-  @param f is the stream
-  @param col (* col) is the column number where we will start to
-    write the text, the ending column will be stored in (* col)
-  @param fields is the fields to write
-*/
-pub unsafe fn mailimf_envelope_fields_write_driver(
-    mut do_write: Option<
-        unsafe fn(_: *mut libc::c_void, _: *const libc::c_char, _: size_t) -> libc::c_int,
-    >,
-    mut data: *mut libc::c_void,
-    mut col: *mut libc::c_int,
-    mut fields: *mut mailimf_fields,
-) -> libc::c_int {
-    let mut cur: *mut clistiter = 0 as *mut clistiter;
-    cur = (*(*fields).fld_list).first;
-    while !cur.is_null() {
-        let mut r: libc::c_int = 0;
-        let mut field: *mut mailimf_field = 0 as *mut mailimf_field;
-        field = (if !cur.is_null() {
-            (*cur).data
-        } else {
-            0 as *mut libc::c_void
-        }) as *mut mailimf_field;
-        if (*field).fld_type != MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int {
-            r = mailimf_field_write_driver(do_write, data, col, field);
-            if r != MAILIMF_NO_ERROR as libc::c_int {
-                return r;
-            }
-        }
-        cur = if !cur.is_null() {
-            (*cur).next
-        } else {
-            0 as *mut clistcell
-        }
-    }
-    return MAILIMF_NO_ERROR as libc::c_int;
-}

mmime/src/mailmime/content.rs

@@ -1,9 +1,9 @@
 use crate::clist::*;
+use crate::mailimf::types::*;
 use crate::mailimf::*;
-use crate::mailimf_types::*;
+use crate::mailmime::types::*;
+use crate::mailmime::types_helper::*;
 use crate::mailmime::*;
-use crate::mailmime_types::*;
-use crate::mailmime_types_helper::*;
 use crate::mmapstring::*;
 use crate::other::*;
 
@@ -80,9 +80,9 @@ pub unsafe fn mailmime_parse(
     mut message: *const libc::c_char,
     mut length: size_t,
     mut indx: *mut size_t,
-    mut result: *mut *mut mailmime,
+    mut result: *mut *mut Mailmime,
 ) -> libc::c_int {
-    let mut mime: *mut mailmime = 0 as *mut mailmime;
+    let mut mime: *mut Mailmime = 0 as *mut Mailmime;
     let mut r: libc::c_int = 0;
     let mut res: libc::c_int = 0;
     let mut content_message: *mut mailmime_content = 0 as *mut mailmime_content;
@@ -174,7 +174,7 @@ unsafe fn mailmime_parse_with_default(
     mut default_type: libc::c_int,
     mut content_type: *mut mailmime_content,
     mut mime_fields: *mut mailmime_fields,
-    mut result: *mut *mut mailmime,
+    mut result: *mut *mut Mailmime,
 ) -> libc::c_int {
     let mut current_block: u64;
     let mut cur_token: size_t = 0;
@@ -184,8 +184,8 @@ unsafe fn mailmime_parse_with_default(
     let mut boundary: *mut libc::c_char = 0 as *mut libc::c_char;
     let mut fields: *mut mailimf_fields = 0 as *mut mailimf_fields;
     let mut list: *mut clist = 0 as *mut clist;
-    let mut msg_mime: *mut mailmime = 0 as *mut mailmime;
+    let mut msg_mime: *mut Mailmime = 0 as *mut Mailmime;
-    let mut mime: *mut mailmime = 0 as *mut mailmime;
+    let mut mime: *mut Mailmime = 0 as *mut Mailmime;
     let mut r: libc::c_int = 0;
     let mut res: libc::c_int = 0;
     let mut preamble: *mut mailmime_data = 0 as *mut mailmime_data;
@@ -312,7 +312,7 @@ unsafe fn mailmime_parse_with_default(
                         res = MAILIMF_ERROR_MEMORY as libc::c_int
                     } else {
                         list = 0 as *mut clist;
-                        msg_mime = 0 as *mut mailmime;
+                        msg_mime = 0 as *mut Mailmime;
                         fields = 0 as *mut mailimf_fields;
                         match body_type {
                             3 => {
@@ -361,7 +361,7 @@ unsafe fn mailmime_parse_with_default(
                                                 current_block = 12065775993741208975;
                                             } else if r == MAILIMF_ERROR_PARSE as libc::c_int {
                                                 mailmime_fields_free(mime_fields);
-                                                msg_mime = 0 as *mut mailmime;
+                                                msg_mime = 0 as *mut Mailmime;
                                                 current_block = 12065775993741208975;
                                             } else {
                                                 mailmime_fields_free(mime_fields);
@@ -456,7 +456,7 @@ unsafe fn mailmime_parse_with_default(
                                         clist_foreach(
                                             list,
                                             ::std::mem::transmute::<
-                                                Option<unsafe fn(_: *mut mailmime) -> ()>,
+                                                Option<unsafe fn(_: *mut Mailmime) -> ()>,
                                                 clist_func,
                                             >(Some(
                                                 mailmime_free,
@@ -605,7 +605,7 @@ unsafe fn mailmime_multipart_body_parse(
                                 break;
                             }
                             let mut bp_token: size_t = 0;
-                            let mut mime_bp: *mut mailmime = 0 as *mut mailmime;
+                            let mut mime_bp: *mut Mailmime = 0 as *mut Mailmime;
                             let mut data_str: *const libc::c_char = 0 as *const libc::c_char;
                             let mut data_size: size_t = 0;
                             let mut fields: *mut mailimf_fields = 0 as *mut mailimf_fields;
@@ -821,7 +821,7 @@ unsafe fn mailmime_multipart_body_parse(
                         clist_foreach(
                             list,
                             ::std::mem::transmute::<
-                                Option<unsafe fn(_: *mut mailmime) -> ()>,
+                                Option<unsafe fn(_: *mut Mailmime) -> ()>,
                                 clist_func,
                             >(Some(mailmime_free)),
                             0 as *mut libc::c_void,
@@ -1344,20 +1344,20 @@ pub unsafe fn mailmime_extract_boundary(
 }
 
 pub unsafe fn mailmime_get_section(
-    mut mime: *mut mailmime,
+    mut mime: *mut Mailmime,
     mut section: *mut mailmime_section,
-    mut result: *mut *mut mailmime,
+    mut result: *mut *mut Mailmime,
 ) -> libc::c_int {
     return mailmime_get_section_list(mime, (*(*section).sec_list).first, result);
 }
 unsafe fn mailmime_get_section_list(
-    mut mime: *mut mailmime,
+    mut mime: *mut Mailmime,
     mut list: *mut clistiter,
-    mut result: *mut *mut mailmime,
+    mut result: *mut *mut Mailmime,
 ) -> libc::c_int {
     let mut id: uint32_t = 0;
-    let mut data: *mut mailmime = 0 as *mut mailmime;
+    let mut data: *mut Mailmime = 0 as *mut Mailmime;
-    let mut submime: *mut mailmime = 0 as *mut mailmime;
+    let mut submime: *mut Mailmime = 0 as *mut Mailmime;
     if list.is_null() {
         *result = mime;
         return MAILIMF_NO_ERROR as libc::c_int;
@@ -1367,14 +1367,14 @@ unsafe fn mailmime_get_section_list(
     } else {
         0 as *mut libc::c_void
     }) as *mut uint32_t);
-    data = 0 as *mut mailmime;
+    data = 0 as *mut Mailmime;
     match (*mime).mm_type {
         1 => return MAILIMF_ERROR_INVAL as libc::c_int,
         2 => {
             data = clist_nth_data(
                 (*mime).mm_data.mm_multipart.mm_mp_list,
                 id.wrapping_sub(1i32 as libc::c_uint) as libc::c_int,
-            ) as *mut mailmime;
+            ) as *mut Mailmime;
             if data.is_null() {
                 return MAILIMF_ERROR_INVAL as libc::c_int;
             }
@@ -1406,7 +1406,7 @@ unsafe fn mailmime_get_section_list(
                     data = clist_nth_data(
                         (*submime).mm_data.mm_multipart.mm_mp_list,
                         id.wrapping_sub(1i32 as libc::c_uint) as libc::c_int,
-                    ) as *mut mailmime;
+                    ) as *mut Mailmime;
                     if data.is_null() {
                         return MAILIMF_ERROR_INVAL as libc::c_int;
                     }
@@ -2147,7 +2147,7 @@ pub unsafe fn mailmime_part_parse_partial(
 }
 
 pub unsafe fn mailmime_get_section_id(
-    mut mime: *mut mailmime,
+    mut mime: *mut Mailmime,
     mut result: *mut *mut mailmime_section,
 ) -> libc::c_int {
     let mut current_block: u64;
@@ -2173,7 +2173,7 @@ pub unsafe fn mailmime_get_section_id(
         let mut id: uint32_t = 0;
         let mut p_id: *mut uint32_t = 0 as *mut uint32_t;
         let mut cur: *mut clistiter = 0 as *mut clistiter;
-        let mut parent: *mut mailmime = 0 as *mut mailmime;
+        let mut parent: *mut Mailmime = 0 as *mut Mailmime;
         r = mailmime_get_section_id((*mime).mm_parent, &mut section_id);
         if r != MAILIMF_NO_ERROR as libc::c_int {
             res = r;

mmime/src/mailmime/decode.rs

@@ -3,8 +3,8 @@ use libc::toupper;
 
 use crate::charconv::*;
 use crate::mailimf::*;
-use crate::mailmime_content::*;
+use crate::mailmime::content::*;
-use crate::mailmime_types::*;
+use crate::mailmime::types::*;
 use crate::mmapstring::*;
 use crate::other::*;
 

mmime/src/mailmime/disposition.rs

@@ -1,10 +1,9 @@
-use libc;
+use libc::{self, toupper};
-use libc::toupper;
 
 use crate::clist::*;
 use crate::mailimf::*;
+use crate::mailmime::types::*;
 use crate::mailmime::*;
-use crate::mailmime_types::*;
 use crate::other::*;
 
 pub const MAILMIME_DISPOSITION_TYPE_EXTENSION: libc::c_uint = 3;

mmime/src/mailmime/mod.rs

@@ -1,13 +1,19 @@
-use libc;
+pub mod content;
+pub mod decode;
+pub mod disposition;
+pub mod types;
+pub mod types_helper;
+pub(crate) mod write_generic;
+pub mod write_mem;
 
 use libc::toupper;
 
 use crate::clist::*;
+use crate::mailimf::types::*;
 use crate::mailimf::*;
-use crate::mailimf_types::*;
+use crate::mailmime::decode::*;
-use crate::mailmime_decode::*;
+use crate::mailmime::disposition::*;
-use crate::mailmime_disposition::*;
+use crate::mailmime::types::*;
-use crate::mailmime_types::*;
 use crate::other::*;
 
 pub const MAILMIME_COMPOSITE_TYPE_EXTENSION: libc::c_uint = 3;

mmime/src/mailmime/types.rs

@@ -1,7 +1,5 @@
-use libc;
-
 use crate::clist::*;
-use crate::mailimf_types::*;
+use crate::mailimf::types::*;
 use crate::mmapstring::*;
 use crate::other::*;
 
@@ -164,9 +162,9 @@ pub const MAILMIME_NONE: unnamed_7 = 0;
 
 #[derive(Copy, Clone)]
 #[repr(C)]
-pub struct mailmime {
+pub struct Mailmime {
     pub mm_parent_type: libc::c_int,
-    pub mm_parent: *mut mailmime,
+    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,
@@ -188,7 +186,7 @@ pub union unnamed_8 {
 #[repr(C)]
 pub struct unnamed_9 {
     pub mm_fields: *mut mailimf_fields,
-    pub mm_msg_mime: *mut mailmime,
+    pub mm_msg_mime: *mut Mailmime,
 }
 /* multi-part */
 #[derive(Copy, Clone)]
@@ -656,15 +654,15 @@ pub unsafe fn mailmime_new(
     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 mm_msg_mime: *mut Mailmime,
-) -> *mut mailmime {
+) -> *mut Mailmime {
-    let mut mime: *mut mailmime = 0 as *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;
+    mime = malloc(::std::mem::size_of::<Mailmime>() as libc::size_t) as *mut Mailmime;
     if mime.is_null() {
-        return 0 as *mut mailmime;
+        return 0 as *mut Mailmime;
     }
-    (*mime).mm_parent = 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;
@@ -681,12 +679,12 @@ pub unsafe fn mailmime_new(
             (*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;
+                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;
+                }) as *mut Mailmime;
                 (*submime).mm_parent = mime;
                 (*submime).mm_parent_type = MAILMIME_MULTIPLE as libc::c_int;
                 (*submime).mm_multipart_pos = cur;
@@ -710,7 +708,7 @@ pub unsafe fn mailmime_new(
     return mime;
 }
 
-pub unsafe fn mailmime_free(mut mime: *mut mailmime) {
+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() {
@@ -727,7 +725,7 @@ pub unsafe fn mailmime_free(mut mime: *mut mailmime) {
             }
             clist_foreach(
                 (*mime).mm_data.mm_multipart.mm_mp_list,
-                ::std::mem::transmute::<Option<unsafe fn(_: *mut mailmime) -> ()>, clist_func>(
+                ::std::mem::transmute::<Option<unsafe fn(_: *mut Mailmime) -> ()>, clist_func>(
                     Some(mailmime_free),
                 ),
                 0 as *mut libc::c_void,

mmime/src/mailmime/types_helper.rs

@@ -1,10 +1,9 @@
-use libc;
 use rand::{thread_rng, Rng};
 
 use crate::clist::*;
-use crate::mailimf_types::*;
+use crate::mailimf::types::*;
+use crate::mailmime::types::*;
 use crate::mailmime::*;
-use crate::mailmime_types::*;
 use crate::other::*;
 
 #[derive(Copy, Clone)]
@@ -637,9 +636,9 @@ pub unsafe fn mailmime_data_new_file(
     );
 }
 
-pub unsafe fn mailmime_new_message_data(mut msg_mime: *mut mailmime) -> *mut mailmime {
+pub unsafe fn mailmime_new_message_data(mut msg_mime: *mut Mailmime) -> *mut Mailmime {
     let mut content: *mut mailmime_content = 0 as *mut mailmime_content;
-    let mut build_info: *mut mailmime = 0 as *mut mailmime;
+    let mut build_info: *mut Mailmime = 0 as *mut Mailmime;
     let mut mime_fields: *mut mailmime_fields = 0 as *mut mailmime_fields;
     content = mailmime_get_content_message();
     if !content.is_null() {
@@ -672,15 +671,15 @@ pub unsafe fn mailmime_new_message_data(mut msg_mime: *mut mailmime) -> *mut mai
         }
         mailmime_content_free(content);
     }
-    return 0 as *mut mailmime;
+    return 0 as *mut Mailmime;
 }
 
 pub unsafe fn mailmime_new_empty(
     mut content: *mut mailmime_content,
     mut mime_fields: *mut mailmime_fields,
-) -> *mut mailmime {
+) -> *mut Mailmime {
     let mut current_block: u64;
-    let mut build_info: *mut mailmime = 0 as *mut mailmime;
+    let mut build_info: *mut Mailmime = 0 as *mut Mailmime;
     let mut list: *mut clist = 0 as *mut clist;
     let mut r: libc::c_int = 0;
     let mut mime_type: libc::c_int = 0;
@@ -823,11 +822,11 @@ pub unsafe fn mailmime_new_empty(
                         0 as *mut mailmime_data,
                         list,
                         0 as *mut mailimf_fields,
-                        0 as *mut mailmime,
+                        0 as *mut Mailmime,
                     );
                     if build_info.is_null() {
                         clist_free(list);
-                        return 0 as *mut mailmime;
+                        return 0 as *mut Mailmime;
                     }
                     return build_info;
                 }
@@ -835,7 +834,7 @@ pub unsafe fn mailmime_new_empty(
         }
         _ => {}
     }
-    return 0 as *mut mailmime;
+    return 0 as *mut Mailmime;
 }
 
 pub unsafe fn mailmime_generate_boundary() -> *mut libc::c_char {
@@ -856,12 +855,12 @@ pub unsafe fn mailmime_generate_boundary() -> *mut libc::c_char {
 pub unsafe fn mailmime_new_with_content(
     mut content_type: *const libc::c_char,
     mut mime_fields: *mut mailmime_fields,
-    mut result: *mut *mut mailmime,
+    mut result: *mut *mut Mailmime,
 ) -> libc::c_int {
     let mut r: libc::c_int = 0;
     let mut cur_token: size_t = 0;
     let mut content: *mut mailmime_content = 0 as *mut mailmime_content;
-    let mut build_info: *mut mailmime = 0 as *mut mailmime;
+    let mut build_info: *mut Mailmime = 0 as *mut Mailmime;
     let mut res: libc::c_int = 0;
     cur_token = 0i32 as size_t;
     r = mailmime_content_parse(
@@ -886,7 +885,7 @@ pub unsafe fn mailmime_new_with_content(
 }
 
 pub unsafe fn mailmime_set_preamble_file(
-    mut build_info: *mut mailmime,
+    mut build_info: *mut Mailmime,
     mut filename: *mut libc::c_char,
 ) -> libc::c_int {
     let mut data: *mut mailmime_data = 0 as *mut mailmime_data;
@@ -906,7 +905,7 @@ pub unsafe fn mailmime_set_preamble_file(
 }
 
 pub unsafe fn mailmime_set_epilogue_file(
-    mut build_info: *mut mailmime,
+    mut build_info: *mut Mailmime,
     mut filename: *mut libc::c_char,
 ) -> libc::c_int {
     let mut data: *mut mailmime_data = 0 as *mut mailmime_data;
@@ -926,7 +925,7 @@ pub unsafe fn mailmime_set_epilogue_file(
 }
 
 pub unsafe fn mailmime_set_preamble_text(
-    mut build_info: *mut mailmime,
+    mut build_info: *mut Mailmime,
     mut data_str: *mut libc::c_char,
     mut length: size_t,
 ) -> libc::c_int {
@@ -947,7 +946,7 @@ pub unsafe fn mailmime_set_preamble_text(
 }
 
 pub unsafe fn mailmime_set_epilogue_text(
-    mut build_info: *mut mailmime,
+    mut build_info: *mut Mailmime,
     mut data_str: *mut libc::c_char,
     mut length: size_t,
 ) -> libc::c_int {
@@ -968,7 +967,7 @@ pub unsafe fn mailmime_set_epilogue_text(
 }
 
 pub unsafe fn mailmime_set_body_file(
-    mut build_info: *mut mailmime,
+    mut build_info: *mut Mailmime,
     mut filename: *mut libc::c_char,
 ) -> libc::c_int {
     let mut encoding: libc::c_int = 0;
@@ -990,7 +989,7 @@ pub unsafe fn mailmime_set_body_file(
 }
 
 pub unsafe fn mailmime_set_body_text(
-    mut build_info: *mut mailmime,
+    mut build_info: *mut Mailmime,
     mut data_str: *mut libc::c_char,
     mut length: size_t,
 ) -> libc::c_int {
@@ -1013,8 +1012,8 @@ pub unsafe fn mailmime_set_body_text(
 }
 
 pub unsafe fn mailmime_add_part(
-    mut build_info: *mut mailmime,
+    mut build_info: *mut Mailmime,
-    mut part: *mut mailmime,
+    mut part: *mut Mailmime,
 ) -> libc::c_int {
     let mut r: libc::c_int = 0;
     if (*build_info).mm_type == MAILMIME_MESSAGE as libc::c_int {
@@ -1039,19 +1038,19 @@ pub unsafe fn mailmime_add_part(
     return MAILIMF_NO_ERROR as libc::c_int;
 }
 
-pub unsafe fn mailmime_remove_part(mut mime: *mut mailmime) {
+pub unsafe fn mailmime_remove_part(mut mime: *mut Mailmime) {
-    let mut parent: *mut mailmime = 0 as *mut mailmime;
+    let mut parent: *mut Mailmime = 0 as *mut Mailmime;
     parent = (*mime).mm_parent;
     if parent.is_null() {
         return;
     }
     match (*mime).mm_parent_type {
         3 => {
-            (*mime).mm_parent = 0 as *mut mailmime;
+            (*mime).mm_parent = 0 as *mut Mailmime;
-            (*parent).mm_data.mm_message.mm_msg_mime = 0 as *mut mailmime
+            (*parent).mm_data.mm_message.mm_msg_mime = 0 as *mut Mailmime
         }
         2 => {
-            (*mime).mm_parent = 0 as *mut mailmime;
+            (*mime).mm_parent = 0 as *mut Mailmime;
             clist_delete(
                 (*parent).mm_data.mm_multipart.mm_mp_list,
                 (*mime).mm_multipart_pos,
@@ -1062,7 +1061,7 @@ pub unsafe fn mailmime_remove_part(mut mime: *mut mailmime) {
 }
 
 pub unsafe fn mailmime_set_imf_fields(
-    mut build_info: *mut mailmime,
+    mut build_info: *mut Mailmime,
     mut mm_fields: *mut mailimf_fields,
 ) {
     (*build_info).mm_data.mm_message.mm_fields = mm_fields;
@@ -1213,11 +1212,11 @@ pub unsafe fn mailmime_single_fields_free(mut single_fields: *mut mailmime_singl
 }
 
 pub unsafe fn mailmime_smart_add_part(
-    mut mime: *mut mailmime,
+    mut mime: *mut Mailmime,
-    mut mime_sub: *mut mailmime,
+    mut mime_sub: *mut Mailmime,
 ) -> libc::c_int {
-    let mut saved_sub: *mut mailmime = 0 as *mut mailmime;
+    let mut saved_sub: *mut Mailmime = 0 as *mut Mailmime;
-    let mut mp: *mut mailmime = 0 as *mut mailmime;
+    let mut mp: *mut Mailmime = 0 as *mut Mailmime;
     let mut res: libc::c_int = 0;
     let mut r: libc::c_int = 0;
     match (*mime).mm_type {
@@ -1278,10 +1277,10 @@ pub unsafe fn mailmime_smart_add_part(
     return res;
 }
 
-pub unsafe fn mailmime_multiple_new(mut type_0: *const libc::c_char) -> *mut mailmime {
+pub unsafe fn mailmime_multiple_new(mut type_0: *const libc::c_char) -> *mut Mailmime {
     let mut mime_fields: *mut mailmime_fields = 0 as *mut mailmime_fields;
     let mut content: *mut mailmime_content = 0 as *mut mailmime_content;
-    let mut mp: *mut mailmime = 0 as *mut mailmime;
+    let mut mp: *mut Mailmime = 0 as *mut Mailmime;
     mime_fields = mailmime_fields_new_empty();
     if !mime_fields.is_null() {
         content = mailmime_content_new_with_str(type_0);
@@ -1295,7 +1294,7 @@ pub unsafe fn mailmime_multiple_new(mut type_0: *const libc::c_char) -> *mut mai
         }
         mailmime_fields_free(mime_fields);
     }
-    return 0 as *mut mailmime;
+    return 0 as *mut Mailmime;
 }
 
 pub unsafe fn mailmime_content_new_with_str(mut str: *const libc::c_char) -> *mut mailmime_content {
@@ -1310,8 +1309,8 @@ pub unsafe fn mailmime_content_new_with_str(mut str: *const libc::c_char) -> *mu
     return content;
 }
 
-pub unsafe fn mailmime_smart_remove_part(mut mime: *mut mailmime) -> libc::c_int {
+pub unsafe fn mailmime_smart_remove_part(mut mime: *mut Mailmime) -> libc::c_int {
-    let mut parent: *mut mailmime = 0 as *mut mailmime;
+    let mut parent: *mut Mailmime = 0 as *mut Mailmime;
     let mut res: libc::c_int = 0;
     parent = (*mime).mm_parent;
     if parent.is_null() {

mmime/src/mailmime/write_generic.rs

@@ -1,11 +1,11 @@
 use std::ffi::CStr;
 
 use crate::clist::*;
-use crate::mailimf_write_generic::*;
+use crate::mailimf::write_generic::*;
+use crate::mailmime::content::*;
+use crate::mailmime::types::*;
+use crate::mailmime::types_helper::*;
 use crate::mailmime::*;
-use crate::mailmime_content::*;
-use crate::mailmime_types::*;
-use crate::mailmime_types_helper::*;
 use crate::other::*;
 
 pub const STATE_INIT: libc::c_uint = 0;
@@ -1017,7 +1017,7 @@ pub unsafe fn mailmime_write_driver(
     >,
     mut data: *mut libc::c_void,
     mut col: *mut libc::c_int,
-    mut build_info: *mut mailmime,
+    mut build_info: *mut Mailmime,
 ) -> libc::c_int {
     if !(*build_info).mm_parent.is_null() {
         return mailmime_sub_write_driver(do_write, data, col, build_info);
@@ -1038,7 +1038,7 @@ unsafe fn mailmime_part_write_driver(
     >,
     mut data: *mut libc::c_void,
     mut col: *mut libc::c_int,
-    mut build_info: *mut mailmime,
+    mut build_info: *mut Mailmime,
 ) -> libc::c_int {
     let mut current_block: u64;
     let mut cur: *mut clistiter = 0 as *mut clistiter;
@@ -1152,8 +1152,8 @@ unsafe fn mailmime_part_write_driver(
                                     current_block = 3546145585875536353;
                                     break;
                                 }
-                                let mut subpart: *mut mailmime = 0 as *mut mailmime;
+                                let mut subpart: *mut Mailmime = 0 as *mut Mailmime;
-                                subpart = (*cur).data as *mut mailmime;
+                                subpart = (*cur).data as *mut Mailmime;
                                 if 0 == first {
                                     r = mailimf_string_write_driver(
                                         do_write,
@@ -1421,7 +1421,7 @@ unsafe fn mailmime_sub_write_driver(
     >,
     mut data: *mut libc::c_void,
     mut col: *mut libc::c_int,
-    mut build_info: *mut mailmime,
+    mut build_info: *mut Mailmime,
 ) -> libc::c_int {
     let mut r: libc::c_int = 0;
     if !(*build_info).mm_content_type.is_null() {

mmime/src/mailmime/write_mem.rs

@@ -1,5 +1,5 @@
-use crate::mailmime_types::*;
+use crate::mailmime::types::*;
-use crate::mailmime_write_generic::*;
+use crate::mailmime::write_generic::*;
 use crate::mmapstring::*;
 use crate::other::*;
 
@@ -41,7 +41,7 @@ pub unsafe fn mailmime_content_type_write_mem(
 pub unsafe fn mailmime_write_mem(
     mut f: *mut MMAPString,
     mut col: *mut libc::c_int,
-    mut build_info: *mut mailmime,
+    mut build_info: *mut Mailmime,
 ) -> libc::c_int {
     return mailmime_write_driver(Some(do_write), f as *mut libc::c_void, col, build_info);
 }

mmime/src/other.rs

@@ -1,10 +1,10 @@
 use chrono::{Datelike, Local, TimeZone, Timelike};
 
 use crate::clist::*;
-use crate::mailimf_types::*;
+use crate::mailimf::types::*;
-use crate::mailimf_types_helper::*;
+use crate::mailimf::types_helper::*;
-use crate::mailmime_types::*;
+use crate::mailmime::types::*;
-use crate::mailmime_types_helper::*;
+use crate::mailmime::types_helper::*;
 
 pub(crate) use libc::{
     calloc, close, free, isalpha, isdigit, malloc, memcmp, memcpy, memmove, memset, realloc,
@@ -132,7 +132,7 @@ 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;
 
-pub unsafe fn mailprivacy_prepare_mime(mut mime: *mut mailmime) {
+pub unsafe fn mailprivacy_prepare_mime(mut mime: *mut Mailmime) {
     let mut cur: *mut clistiter = 0 as *mut clistiter;
     match (*mime).mm_type {
         1 => {
@@ -143,12 +143,12 @@ pub unsafe fn mailprivacy_prepare_mime(mut mime: *mut mailmime) {
         2 => {
             cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first;
             while !cur.is_null() {
-                let mut child: *mut mailmime = 0 as *mut mailmime;
+                let mut child: *mut Mailmime = 0 as *mut Mailmime;
                 child = (if !cur.is_null() {
                     (*cur).data
                 } else {
                     0 as *mut libc::c_void
-                }) as *mut mailmime;
+                }) as *mut Mailmime;
                 mailprivacy_prepare_mime(child);
                 cur = if !cur.is_null() {
                     (*cur).next
@@ -166,7 +166,7 @@ pub unsafe fn mailprivacy_prepare_mime(mut mime: *mut mailmime) {
     };
 }
 
-unsafe fn prepare_mime_single(mut mime: *mut mailmime) {
+unsafe fn prepare_mime_single(mut mime: *mut Mailmime) {
     let mut single_fields: mailmime_single_fields = mailmime_single_fields {
         fld_content: 0 as *mut mailmime_content,
         fld_content_charset: 0 as *mut libc::c_char,
@@ -251,10 +251,10 @@ unsafe fn prepare_mime_single(mut mime: *mut mailmime) {
 }
 
 pub unsafe fn mailmime_substitute(
-    mut old_mime: *mut mailmime,
+    mut old_mime: *mut Mailmime,
-    mut new_mime: *mut mailmime,
+    mut new_mime: *mut Mailmime,
 ) -> libc::c_int {
-    let mut parent: *mut mailmime = 0 as *mut mailmime;
+    let mut parent: *mut Mailmime = 0 as *mut Mailmime;
     parent = (*old_mime).mm_parent;
     if parent.is_null() {
         return MAIL_ERROR_INVAL as libc::c_int;
@@ -266,7 +266,7 @@ pub unsafe fn mailmime_substitute(
     }
     (*new_mime).mm_parent = parent;
     (*new_mime).mm_parent_type = (*old_mime).mm_parent_type;
-    (*old_mime).mm_parent = 0 as *mut mailmime;
+    (*old_mime).mm_parent = 0 as *mut Mailmime;
     (*old_mime).mm_parent_type = MAILMIME_NONE as libc::c_int;
     return MAIL_NO_ERROR as libc::c_int;
 }

src/aheader.rs

@@ -3,7 +3,7 @@ use std::ffi::CStr;
 use std::str::FromStr;
 use std::{fmt, str};
 
-use mmime::mailimf_types::*;
+use mmime::mailimf::types::*;
 
 use crate::constants::*;
 use crate::contact::*;

src/dc_imex.rs

@@ -3,7 +3,7 @@ use std::path::Path;
 use std::ptr;
 
 use libc::{free, strlen};
-use mmime::mailmime_content::*;
+use mmime::mailmime::content::*;
 use mmime::mmapstring::*;
 use mmime::other::*;
 use rand::{thread_rng, Rng};

src/dc_mimeparser.rs

@@ -6,12 +6,12 @@ use charset::Charset;
 use deltachat_derive::{FromSql, ToSql};
 use libc::{strcmp, strlen, strncmp};
 use mmime::clist::*;
+use mmime::mailimf::types::*;
 use mmime::mailimf::*;
-use mmime::mailimf_types::*;
+use mmime::mailmime::content::*;
+use mmime::mailmime::disposition::*;
+use mmime::mailmime::types::*;
 use mmime::mailmime::*;
-use mmime::mailmime_content::*;
-use mmime::mailmime_disposition::*;
-use mmime::mailmime_types::*;
 use mmime::mmapstring::*;
 use mmime::other::*;
 
@@ -31,7 +31,7 @@ use crate::stock::StockMessage;
 pub struct MimeParser<'a> {
     pub context: &'a Context,
     pub parts: Vec<Part>,
-    pub mimeroot: *mut mailmime,
+    pub mimeroot: *mut Mailmime,
     pub header: HashMap<String, *mut mailimf_field>,
     pub header_root: *mut mailimf_fields,
     pub header_protected: *mut mailimf_fields,
@@ -40,7 +40,7 @@ pub struct MimeParser<'a> {
     pub decrypting_failed: bool,
     pub e2ee_helper: E2eeHelper,
     pub is_forwarded: bool,
-    pub reports: Vec<*mut mailmime>,
+    pub reports: Vec<*mut Mailmime>,
     pub is_system_message: SystemMessage,
     pub location_kml: Option<location::Kml>,
     pub message_kml: Option<location::Kml>,
@@ -363,7 +363,7 @@ impl<'a> MimeParser<'a> {
         }
     }
 
-    unsafe fn parse_mime_recursive(&mut self, mime: *mut mailmime) -> bool {
+    unsafe fn parse_mime_recursive(&mut self, mime: *mut Mailmime) -> bool {
         if mime.is_null() {
             return false;
         }
@@ -428,7 +428,7 @@ impl<'a> MimeParser<'a> {
         }
     }
 
-    unsafe fn handle_multiple(&mut self, mime: *mut mailmime) -> bool {
+    unsafe fn handle_multiple(&mut self, mime: *mut Mailmime) -> bool {
         let mut any_part_added = false;
         match mailmime_get_mime_type(mime) {
             /* Most times, mutlipart/alternative contains true alternatives
@@ -468,7 +468,7 @@ impl<'a> MimeParser<'a> {
                 however, most times it seems okay. */
                 let cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first;
                 if !cur.is_null() {
-                    any_part_added = self.parse_mime_recursive((*cur).data as *mut mailmime);
+                    any_part_added = self.parse_mime_recursive((*cur).data as *mut Mailmime);
                 }
             }
             (DC_MIMETYPE_MP_NOT_DECRYPTABLE, _, _) => {
@@ -538,7 +538,7 @@ impl<'a> MimeParser<'a> {
                             plain_cnt += 1;
                         }
                         (DC_MIMETYPE_TEXT_HTML, _, _) => {
-                            html_part = cur_data as *mut mailmime;
+                            html_part = cur_data as *mut Mailmime;
                             html_cnt += 1;
                         }
                         _ => {}
@@ -565,7 +565,7 @@ impl<'a> MimeParser<'a> {
         any_part_added
     }
 
-    unsafe fn add_single_part_if_known(&mut self, mime: *mut mailmime) -> bool {
+    unsafe fn add_single_part_if_known(&mut self, mime: *mut Mailmime) -> bool {
         // return true if a part was added
         if mime.is_null() || (*mime).mm_data.mm_single.is_null() {
             return false;
@@ -969,7 +969,7 @@ unsafe fn hash_header(out: &mut HashMap<String, *mut mailimf_field>, in_0: *cons
     }
 }
 
-unsafe fn mailmime_get_mime_type(mime: *mut mailmime) -> (libc::c_int, Viewtype, Option<String>) {
+unsafe fn mailmime_get_mime_type(mime: *mut Mailmime) -> (libc::c_int, Viewtype, Option<String>) {
     let c = (*mime).mm_content_type;
 
     let unknown_type = (0, Viewtype::Unknown, None);
@@ -1093,7 +1093,7 @@ fn reconcat_mime(typ: Option<&str>, subtype: Option<&str>) -> String {
     format!("{}/{}", typ, subtype)
 }
 
-unsafe fn mailmime_is_attachment_disposition(mime: *mut mailmime) -> bool {
+unsafe fn mailmime_is_attachment_disposition(mime: *mut Mailmime) -> bool {
     if (*mime).mm_mime_fields.is_null() {
         return false;
     }
@@ -1118,7 +1118,7 @@ unsafe fn mailmime_is_attachment_disposition(mime: *mut mailmime) -> bool {
 
 /* low-level-tools for working with mailmime structures directly */
 pub unsafe fn mailmime_find_ct_parameter(
-    mime: *mut mailmime,
+    mime: *mut Mailmime,
     name: &str,
 ) -> *mut mailmime_parameter {
     if mime.is_null()
@@ -1140,7 +1140,7 @@ pub unsafe fn mailmime_find_ct_parameter(
     ptr::null_mut()
 }
 
-pub unsafe fn mailmime_transfer_decode(mime: *mut mailmime) -> Result<Vec<u8>, Error> {
+pub unsafe fn mailmime_transfer_decode(mime: *mut Mailmime) -> Result<Vec<u8>, Error> {
     ensure!(!mime.is_null(), "invalid inputs");
 
     let mut mime_transfer_encoding = MAILMIME_MECHANISM_BINARY as libc::c_int;
@@ -1295,7 +1295,7 @@ pub unsafe fn mailimf_find_field(
 }
 
 /*the result is a pointer to mime, must not be freed*/
-pub unsafe fn mailmime_find_mailimf_fields(mime: *mut mailmime) -> *mut mailimf_fields {
+pub unsafe fn mailmime_find_mailimf_fields(mime: *mut Mailmime) -> *mut mailimf_fields {
     if mime.is_null() {
         return ptr::null_mut();
     }
@@ -1353,7 +1353,7 @@ mod tests {
         unsafe {
             let txt: *const libc::c_char =
                 b"FieldA: ValueA\nFieldB: ValueB\n\x00" as *const u8 as *const libc::c_char;
-            let mut mime: *mut mailmime = ptr::null_mut();
+            let mut mime: *mut Mailmime = ptr::null_mut();
             let mut dummy = 0;
             let res = mailmime_parse(txt, strlen(txt), &mut dummy, &mut mime);
 

src/dc_receive_imf.rs

@@ -4,11 +4,11 @@ use std::ptr;
 use itertools::join;
 use libc::{free, strcmp, strlen};
 use mmime::clist::*;
+use mmime::mailimf::types::*;
 use mmime::mailimf::*;
-use mmime::mailimf_types::*;
+use mmime::mailmime::content::*;
+use mmime::mailmime::types::*;
 use mmime::mailmime::*;
-use mmime::mailmime_content::*;
-use mmime::mailmime_types::*;
 use mmime::other::*;
 use sha2::{Digest, Sha256};
 
@@ -788,7 +788,7 @@ unsafe fn handle_reports(
                     .data
                 } else {
                     ptr::null_mut()
-                }) as *mut mailmime;
+                }) as *mut Mailmime;
 
                 if !report_data.is_null()
                     && (*(*(*report_data).mm_content_type).ct_type).tp_type

src/dc_strencode.rs

@@ -4,7 +4,7 @@ use std::ptr;
 
 use charset::Charset;
 use libc::{free, strlen};
-use mmime::mailmime_decode::*;
+use mmime::mailmime::decode::mailmime_encoded_phrase_parse;
 use mmime::mmapstring::*;
 use mmime::other::*;
 use percent_encoding::{percent_decode, utf8_percent_encode, AsciiSet, CONTROLS};

src/dc_tools.rs

@@ -11,7 +11,7 @@ use std::{fmt, fs, ptr};
 use chrono::{Local, TimeZone};
 use libc::{memcpy, strcpy, strlen, uintptr_t};
 use mmime::clist::*;
-use mmime::mailimf_types::*;
+use mmime::mailimf::types::*;
 use rand::{thread_rng, Rng};
 
 use crate::context::Context;

src/e2ee.rs

@@ -8,14 +8,14 @@ use std::str::FromStr;
 
 use libc::{free, strcmp, strlen, strncmp};
 use mmime::clist::*;
+use mmime::mailimf::types::*;
+use mmime::mailimf::types_helper::*;
 use mmime::mailimf::*;
-use mmime::mailimf_types::*;
+use mmime::mailmime::content::*;
-use mmime::mailimf_types_helper::*;
+use mmime::mailmime::types::*;
+use mmime::mailmime::types_helper::*;
+use mmime::mailmime::write_mem::*;
 use mmime::mailmime::*;
-use mmime::mailmime_content::*;
-use mmime::mailmime_types::*;
-use mmime::mailmime_types_helper::*;
-use mmime::mailmime_write_mem::*;
 use mmime::mailprivacy_prepare_mime;
 use mmime::mmapstring::*;
 use mmime::{mailmime_substitute, MAILIMF_NO_ERROR, MAIL_NO_ERROR};
@@ -81,7 +81,7 @@ impl EncryptHelper {
         e2ee_guaranteed: bool,
         min_verified: libc::c_int,
         do_gossip: bool,
-        mut in_out_message: *mut mailmime,
+        mut in_out_message: *mut Mailmime,
         imffields_unprotected: *mut mailimf_fields,
     ) -> Result<bool> {
         /* libEtPan's pgp_encrypt_mime() takes the parent as the new root.
@@ -146,12 +146,12 @@ impl EncryptHelper {
         /* encrypt message */
         unsafe {
             mailprivacy_prepare_mime(in_out_message);
-            let mut part_to_encrypt: *mut mailmime =
+            let mut part_to_encrypt: *mut Mailmime =
                 (*in_out_message).mm_data.mm_message.mm_msg_mime;
             (*part_to_encrypt).mm_parent = ptr::null_mut();
             let imffields_encrypted: *mut mailimf_fields = 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: *mut mailmime = mailmime_new(
+            let message_to_encrypt: *mut Mailmime = mailmime_new(
                 MAILMIME_MESSAGE as libc::c_int,
                 ptr::null(),
                 0 as libc::size_t,
@@ -248,7 +248,7 @@ impl EncryptHelper {
 
             if let Ok(ctext_v) = ctext {
                 /* create MIME-structure that will contain the encrypted text */
-                let mut encrypted_part: *mut mailmime = new_data_part(
+                let mut encrypted_part: *mut Mailmime = new_data_part(
                     ptr::null_mut(),
                     0 as libc::size_t,
                     "multipart/encrypted",
@@ -256,7 +256,7 @@ impl EncryptHelper {
                 )?;
                 let content: *mut mailmime_content = (*encrypted_part).mm_content_type;
                 wrapmime::append_ct_param(content, "protocol", "application/pgp-encrypted")?;
-                let version_mime: *mut mailmime = new_data_part(
+                let version_mime: *mut Mailmime = new_data_part(
                     VERSION_CONTENT.as_mut_ptr() as *mut libc::c_void,
                     strlen(VERSION_CONTENT.as_mut_ptr()),
                     "application/pgp-encrypted",
@@ -266,7 +266,7 @@ impl EncryptHelper {
 
                 // we assume that ctext_v is not dropped until the end
                 // of this if-scope
-                let ctext_part: *mut mailmime = new_data_part(
+                let ctext_part: *mut Mailmime = new_data_part(
                     ctext_v.as_ptr() as *mut libc::c_void,
                     ctext_v.len(),
                     "application/octet-stream",
@@ -304,7 +304,7 @@ impl E2eeHelper {
         }
     }
 
-    pub unsafe fn decrypt(&mut self, context: &Context, in_out_message: *mut mailmime) {
+    pub unsafe fn decrypt(&mut self, context: &Context, in_out_message: *mut Mailmime) {
         /* return values: 0=nothing to decrypt/cannot decrypt, 1=sth. decrypted
         (to detect parts that could not be decrypted, simply look for left "multipart/encrypted" MIME types */
         /*just a pointer into mailmime structure, must not be freed*/
@@ -426,7 +426,7 @@ fn new_data_part(
     data_bytes: libc::size_t,
     content_type: &str,
     default_encoding: u32,
-) -> Result<*mut mailmime> {
+) -> Result<*mut Mailmime> {
     let content = new_content_type(&content_type)?;
     unsafe {
         let mut encoding: *mut mailmime_mechanism = ptr::null_mut();
@@ -565,7 +565,7 @@ unsafe fn update_gossip_peerstates(
 
 unsafe fn decrypt_recursive(
     context: &Context,
-    mime: *mut mailmime,
+    mime: *mut Mailmime,
     private_keyring: &Keyring,
     public_keyring_for_validate: &Keyring,
     ret_valid_signatures: &mut HashSet<String>,
@@ -585,10 +585,10 @@ unsafe fn decrypt_recursive(
             ) == 0i32
         {
             for cur_data in (*(*mime).mm_data.mm_multipart.mm_mp_list).into_iter() {
-                let mut decrypted_mime: *mut mailmime = ptr::null_mut();
+                let mut decrypted_mime: *mut Mailmime = ptr::null_mut();
                 if decrypt_part(
                     context,
-                    cur_data as *mut mailmime,
+                    cur_data as *mut Mailmime,
                     private_keyring,
                     public_keyring_for_validate,
                     ret_valid_signatures,
@@ -618,7 +618,7 @@ unsafe fn decrypt_recursive(
             for cur_data in (*(*mime).mm_data.mm_multipart.mm_mp_list).into_iter() {
                 if decrypt_recursive(
                     context,
-                    cur_data as *mut mailmime,
+                    cur_data as *mut Mailmime,
                     private_keyring,
                     public_keyring_for_validate,
                     ret_valid_signatures,
@@ -654,11 +654,11 @@ unsafe fn decrypt_recursive(
 
 unsafe fn decrypt_part(
     _context: &Context,
-    mime: *mut mailmime,
+    mime: *mut Mailmime,
     private_keyring: &Keyring,
     public_keyring_for_validate: &Keyring,
     ret_valid_signatures: &mut HashSet<String>,
-    ret_decrypted_mime: *mut *mut mailmime,
+    ret_decrypted_mime: *mut *mut Mailmime,
 ) -> bool {
     let mut ok_to_continue = true;
     let mime_data: *mut mailmime_data;
@@ -738,7 +738,7 @@ unsafe fn decrypt_part(
                     let plain_buf = plain.as_ptr() as *const libc::c_char;
 
                     let mut index: libc::size_t = 0;
-                    let mut decrypted_mime: *mut mailmime = ptr::null_mut();
+                    let mut decrypted_mime: *mut Mailmime = ptr::null_mut();
                     if mailmime_parse(
                         plain_buf as *const _,
                         plain_bytes,
@@ -794,7 +794,7 @@ unsafe fn has_decrypted_pgp_armor(str__: *const libc::c_char, mut str_bytes: lib
 /// 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.
-unsafe fn contains_report(mime: *mut mailmime) -> bool {
+unsafe fn contains_report(mime: *mut Mailmime) -> bool {
     if (*mime).mm_type == MAILMIME_MULTIPLE as libc::c_int {
         if (*(*(*mime).mm_content_type).ct_type).tp_type
             == MAILMIME_TYPE_COMPOSITE_TYPE as libc::c_int
@@ -811,7 +811,7 @@ unsafe fn contains_report(mime: *mut mailmime) -> bool {
             return true;
         }
         for cur_data in (*(*(*mime).mm_mime_fields).fld_list).into_iter() {
-            if contains_report(cur_data as *mut mailmime) {
+            if contains_report(cur_data as *mut Mailmime) {
                 return true;
             }
         }

src/mimefactory.rs

@@ -3,12 +3,12 @@ use std::ptr;
 
 use chrono::TimeZone;
 use mmime::clist::*;
-use mmime::mailimf_types::*;
+use mmime::mailimf::types::*;
-use mmime::mailimf_types_helper::*;
+use mmime::mailimf::types_helper::*;
-use mmime::mailmime_disposition::*;
+use mmime::mailmime::disposition::*;
-use mmime::mailmime_types::*;
+use mmime::mailmime::types::*;
-use mmime::mailmime_types_helper::*;
+use mmime::mailmime::types_helper::*;
-use mmime::mailmime_write_mem::*;
+use mmime::mailmime::write_mem::*;
 use mmime::mmapstring::*;
 use mmime::other::*;
 
@@ -86,7 +86,7 @@ impl<'a> MimeFactory<'a> {
 
     pub fn finalize_mime_message(
         &mut self,
-        message: *mut mailmime,
+        message: *mut Mailmime,
         encrypted: bool,
         gossiped: bool,
     ) -> Result<(), Error> {
@@ -236,12 +236,12 @@ impl<'a> MimeFactory<'a> {
             );
         }
 
-        let cleanup = |message: *mut mailmime| {
+        let cleanup = |message: *mut Mailmime| {
             if !message.is_null() {
                 mailmime_free(message);
             }
         };
-        let message = mailmime_new_message_data(0 as *mut mailmime);
+        let message = mailmime_new_message_data(0 as *mut Mailmime);
         ensure!(!message.is_null(), "could not create mime message data");
 
         mailmime_set_imf_fields(message, imf_fields);
@@ -257,7 +257,7 @@ impl<'a> MimeFactory<'a> {
                 /* Render a normal message
                  *********************************************************************/
                 let chat = self.chat.as_ref().unwrap();
-                let mut meta_part: *mut mailmime = ptr::null_mut();
+                let mut meta_part: *mut Mailmime = ptr::null_mut();
                 let mut placeholdertext = None;
 
                 if chat.typ == Chattype::VerifiedGroup {
@@ -589,7 +589,7 @@ impl<'a> MimeFactory<'a> {
                     wrapmime::new_content_type("message/disposition-notification")?;
                 let mime_fields_0: *mut mailmime_fields =
                     mailmime_fields_new_encoding(MAILMIME_MECHANISM_8BIT as libc::c_int);
-                let mach_mime_part: *mut mailmime =
+                let mach_mime_part: *mut Mailmime =
                     mailmime_new_empty(content_type_0, mime_fields_0);
                 wrapmime::set_body_text(mach_mime_part, &message_text2)?;
                 mailmime_add_part(multipart, mach_mime_part);
@@ -821,7 +821,7 @@ fn build_body_file(
     context: &Context,
     msg: &Message,
     base_name: &str,
-) -> Result<(*mut mailmime, String), Error> {
+) -> Result<(*mut Mailmime, String), Error> {
     let path_filename = match msg.param.get(Param::File) {
         None => {
             bail!("msg has no filename");

src/wrapmime.rs

@@ -3,12 +3,12 @@ use std::ffi::CString;
 use crate::dc_tools::*;
 use crate::error::Error;
 use mmime::clist::*;
-use mmime::mailimf_types::*;
+use mmime::mailimf::types::*;
-use mmime::mailimf_types_helper::*;
+use mmime::mailimf::types_helper::*;
+use mmime::mailmime::disposition::*;
+use mmime::mailmime::types::*;
+use mmime::mailmime::types_helper::*;
 use mmime::mailmime::*;
-use mmime::mailmime_disposition::*;
-use mmime::mailmime_types::*;
-use mmime::mailmime_types_helper::*;
 use mmime::other::*;
 
 #[macro_export]
@@ -26,7 +26,7 @@ macro_rules! clist_append {
 }
 
 pub fn add_filename_part(
-    message: *mut mailmime,
+    message: *mut Mailmime,
     basename: &str,
     mime_type: &str,
     file_content: &str,
@@ -57,9 +57,9 @@ pub fn new_custom_field(fields: *mut mailimf_fields, name: &str, value: &str) {
     }
 }
 
-pub fn build_body_text(text: &str) -> Result<*mut mailmime, Error> {
+pub fn build_body_text(text: &str) -> Result<*mut Mailmime, Error> {
     let mime_fields: *mut mailmime_fields;
-    let message_part: *mut mailmime;
+    let message_part: *mut Mailmime;
 
     let content = new_content_type("text/plain")?;
     append_ct_param(content, "charset", "utf-8")?;
@@ -104,7 +104,7 @@ pub fn new_content_type(content_type: &str) -> Result<*mut mailmime_content, Err
     Ok(content)
 }
 
-pub fn set_body_text(part: *mut mailmime, text: &str) -> Result<(), Error> {
+pub fn set_body_text(part: *mut Mailmime, text: &str) -> Result<(), Error> {
     use libc::strlen;
     unsafe {
         let text_c = text.strdup();