Mirrors/chatmail-core
1
0
Fork 0
mirror of https://github.com/chatmail/core.git synced 2026-04-21 15:36:30 +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

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