Mirrors/chatmail-core
1
0
Fork 0
mirror of https://github.com/chatmail/core.git synced 2026-04-23 00:16:34 +03:00
Code Issues Packages Projects Releases Wiki Activity

refactor(mmime): split up into modules

Browse Source
This commit is contained in:
dignifiedquire
2019-09-26 00:37:48 +02:00
parent 8d702d0b77
commit 452bce07e1
24 changed files with 269 additions and 251 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
mmime/src/constants.rs Normal file
View File

@@ -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;

32
mmime/src/lib.rs
View File

@@ -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

13
mmime/src/mailimf.rs → mmime/src/mailimf/mod.rs
View File

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

0
mmime/src/mailimf_types.rs → mmime/src/mailimf/types.rs
View File

2
mmime/src/mailimf_types_helper.rs → mmime/src/mailimf/types_helper.rs
View File

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

42
mmime/src/mailimf_write_generic.rs → mmime/src/mailimf/write_generic.rs
View File

@@ -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;
}

48
mmime/src/mailmime_content.rs → mmime/src/mailmime/content.rs
View File

@@ -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 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 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 submime: *mut mailmime = 0 as *mut mailmime;
let mut data: *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;

4
mmime/src/mailmime_decode.rs → mmime/src/mailmime/decode.rs
View File

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

5
mmime/src/mailmime_disposition.rs → mmime/src/mailmime/disposition.rs
View File

@@ -1,10 +1,9 @@
use libc;
use libc::toupper;
use libc::{self, 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;

16
mmime/src/mailmime.rs → mmime/src/mailmime/mod.rs
View File

@@ -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_disposition::*;
use crate::mailmime_types::*;
use crate::mailmime::decode::*;
use crate::mailmime::disposition::*;
use crate::mailmime::types::*;
use crate::other::*;
pub const MAILMIME_COMPOSITE_TYPE_EXTENSION: libc::c_uint = 3;

30
mmime/src/mailmime_types.rs → mmime/src/mailmime/types.rs
View File

@@ -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 mailmime {
let mut mime: *mut mailmime = 0 as *mut mailmime;
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;
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,

71
mmime/src/mailmime_types_helper.rs → mmime/src/mailmime/types_helper.rs
View File

@@ -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 part: *mut mailmime,
mut build_info: *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) {
let mut parent: *mut mailmime = 0 as *mut mailmime;
pub unsafe fn mailmime_remove_part(mut mime: *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;
(*parent).mm_data.mm_message.mm_msg_mime = 0 as *mut mailmime
(*mime).mm_parent = 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_sub: *mut mailmime,
mut mime: *mut Mailmime,
mut mime_sub: *mut Mailmime,
) -> libc::c_int {
let mut saved_sub: *mut mailmime = 0 as *mut mailmime;
let mut mp: *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 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 {
let mut parent: *mut mailmime = 0 as *mut mailmime;
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 res: libc::c_int = 0;
parent = (*mime).mm_parent;
if parent.is_null() {

18
mmime/src/mailmime_write_generic.rs → mmime/src/mailmime/write_generic.rs
View File

@@ -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;
subpart = (*cur).data as *mut mailmime;
let mut subpart: *mut Mailmime = 0 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() {

6
mmime/src/mailmime_write_mem.rs → mmime/src/mailmime/write_mem.rs
View File

@@ -1,5 +1,5 @@
use crate::mailmime_types::*;
use crate::mailmime_write_generic::*;
use crate::mailmime::types::*;
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);
}

24
mmime/src/other.rs
View File

@@ -1,10 +1,10 @@
use chrono::{Datelike, Local, TimeZone, Timelike};
use crate::clist::*;
use crate::mailimf_types::*;
use crate::mailimf_types_helper::*;
use crate::mailmime_types::*;
use crate::mailmime_types_helper::*;
use crate::mailimf::types::*;
use crate::mailimf::types_helper::*;
use crate::mailmime::types::*;
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 new_mime: *mut mailmime,
mut old_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;
}

2
src/aheader.rs
View File

@@ -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::*;

2
src/dc_imex.rs
View File

@@ -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};

34
src/dc_mimeparser.rs
View File

@@ -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);

8
src/dc_receive_imf.rs
View File

@@ -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

2
src/dc_strencode.rs
View File

@@ -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};

2
src/dc_tools.rs
View File

@@ -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;

46
src/e2ee.rs
View File

@@ -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::mailimf_types_helper::*;
use mmime::mailmime::content::*;
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;
}
}

24
src/mimefactory.rs
View File

@@ -3,12 +3,12 @@ use std::ptr;
use chrono::TimeZone;
use mmime::clist::*;
use mmime::mailimf_types::*;
use mmime::mailimf_types_helper::*;
use mmime::mailmime_disposition::*;
use mmime::mailmime_types::*;
use mmime::mailmime_types_helper::*;
use mmime::mailmime_write_mem::*;
use mmime::mailimf::types::*;
use mmime::mailimf::types_helper::*;
use mmime::mailmime::disposition::*;
use mmime::mailmime::types::*;
use mmime::mailmime::types_helper::*;
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");

18
src/wrapmime.rs
View File

@@ -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_helper::*;
use mmime::mailimf::types::*;
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();