From 475ad0f93a422df87806ee6588039e16e1271092 Mon Sep 17 00:00:00 2001 From: dignifiedquire Date: Sat, 28 Sep 2019 23:05:10 -0600 Subject: [PATCH] compile --- mmime/src/mailimf/mod.rs | 396 +++++++++++++---------------- mmime/src/mailimf/types.rs | 5 +- mmime/src/mailimf/types_helper.rs | 40 +-- mmime/src/mailimf/write_generic.rs | 168 +++--------- mmime/src/mailmime/content.rs | 6 +- mmime/src/mailmime/mod.rs | 47 +--- mmime/src/other.rs | 123 ++------- 7 files changed, 266 insertions(+), 519 deletions(-) diff --git a/mmime/src/mailimf/mod.rs b/mmime/src/mailimf/mod.rs index d3d577bcd..17cb7b04d 100644 --- a/mmime/src/mailimf/mod.rs +++ b/mmime/src/mailimf/mod.rs @@ -249,33 +249,32 @@ unsafe fn mailimf_field_parse( message: *const libc::c_char, length: size_t, indx: *mut size_t, - result: &mut mailimf_field, -) -> libc::c_int { +) -> Result { let mut cur_token = *indx; - let try_optional = false; + let mut try_optional = false; - let mut return_path: *mut mailimf_return = 0 as *mut mailimf_return; - let mut resent_date: *mut mailimf_orig_date = 0 as *mut mailimf_orig_date; - let mut resent_from: *mut mailimf_from = 0 as *mut mailimf_from; - let mut resent_sender: *mut mailimf_sender = 0 as *mut mailimf_sender; - let mut resent_to: *mut mailimf_to = 0 as *mut mailimf_to; - let mut resent_cc: *mut mailimf_cc = 0 as *mut mailimf_cc; - let mut resent_bcc: *mut mailimf_bcc = 0 as *mut mailimf_bcc; - let mut resent_msg_id: *mut mailimf_message_id = 0 as *mut mailimf_message_id; - let mut orig_date: *mut mailimf_orig_date = 0 as *mut mailimf_orig_date; - let mut from: *mut mailimf_from = 0 as *mut mailimf_from; - let mut sender: *mut mailimf_sender = 0 as *mut mailimf_sender; - let mut reply_to: *mut mailimf_reply_to = 0 as *mut mailimf_reply_to; - let mut to: *mut mailimf_to = 0 as *mut mailimf_to; - let mut cc: *mut mailimf_cc = 0 as *mut mailimf_cc; - let mut bcc: *mut mailimf_bcc = 0 as *mut mailimf_bcc; - let mut message_id: *mut mailimf_message_id = 0 as *mut mailimf_message_id; - let mut in_reply_to: *mut mailimf_in_reply_to = 0 as *mut mailimf_in_reply_to; - let mut references: *mut mailimf_references = 0 as *mut mailimf_references; - let mut subject: *mut mailimf_subject = 0 as *mut mailimf_subject; - let mut comments: *mut mailimf_comments = 0 as *mut mailimf_comments; - let mut keywords: *mut mailimf_keywords = 0 as *mut mailimf_keywords; - let mut optional_field: *mut mailimf_optional_field = 0 as *mut mailimf_optional_field; + let mut return_path = 0 as *mut mailimf_return; + let mut resent_date = 0 as *mut mailimf_orig_date; + let mut resent_from = 0 as *mut mailimf_from; + let mut resent_sender = 0 as *mut mailimf_sender; + let mut resent_to = 0 as *mut mailimf_to; + let mut resent_cc = 0 as *mut mailimf_cc; + let mut resent_bcc = 0 as *mut mailimf_bcc; + let mut resent_msg_id = 0 as *mut mailimf_message_id; + let mut orig_date = 0 as *mut mailimf_orig_date; + let mut from = 0 as *mut mailimf_from; + let mut sender = 0 as *mut mailimf_sender; + let mut reply_to = 0 as *mut mailimf_reply_to; + let mut to = 0 as *mut mailimf_to; + let mut cc = 0 as *mut mailimf_cc; + let mut bcc = 0 as *mut mailimf_bcc; + let mut message_id = 0 as *mut mailimf_message_id; + let mut in_reply_to = 0 as *mut mailimf_in_reply_to; + let mut references = 0 as *mut mailimf_references; + let mut subject = 0 as *mut mailimf_subject; + let mut comments = 0 as *mut mailimf_comments; + let mut keywords = 0 as *mut mailimf_keywords; + let mut optional_field = 0 as *mut mailimf_optional_field; let guessed_type = guess_header_type(message, length, cur_token); @@ -286,253 +285,232 @@ unsafe fn mailimf_field_parse( 9 => { r = mailimf_orig_date_parse(message, length, &mut cur_token, &mut orig_date); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::OrigDate(orig_date); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::OrigDate(orig_date)); } else if r == MAILIMF_ERROR_PARSE as libc::c_int { try_optional = true; } else { - return r; + return Err(r); } } 10 => { r = mailimf_from_parse(message, length, &mut cur_token, &mut from); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::From(from); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::From(from)); } else if r == MAILIMF_ERROR_PARSE as libc::c_int { try_optional = true; } else { - return r; + return Err(r); } } 11 => { r = mailimf_sender_parse(message, length, &mut cur_token, &mut sender); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::Sender(sender); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::Sender(sender)); } else if r == MAILIMF_ERROR_PARSE as libc::c_int { try_optional = true; } else { - return r; + return Err(r); } } 12 => { r = mailimf_reply_to_parse(message, length, &mut cur_token, &mut reply_to); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::ReplyTo(reply_to); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::ReplyTo(reply_to)); } else if r == MAILIMF_ERROR_PARSE as libc::c_int { try_optional = true; } else { - return r; + return Err(r); } } 13 => { r = mailimf_to_parse(message, length, &mut cur_token, &mut to); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::To(to); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::To(to)); } else if r == MAILIMF_ERROR_PARSE as libc::c_int { try_optional = true; } else { - return r; + return Err(r); } } 14 => { r = mailimf_cc_parse(message, length, &mut cur_token, &mut cc); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::Cc(cc); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::Cc(cc)); } else if r == MAILIMF_ERROR_PARSE as libc::c_int { try_optional = true; } else { - return r; + return Err(r); } } 15 => { r = mailimf_bcc_parse(message, length, &mut cur_token, &mut bcc); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::Bcc(bcc); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::Bcc(bcc)); } else if r == MAILIMF_ERROR_PARSE as libc::c_int { try_optional = true; } else { - return r; + return Err(r); } } 16 => { r = mailimf_message_id_parse(message, length, &mut cur_token, &mut message_id); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::MessageId(message_id); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::MessageId(message_id)); } else if r == MAILIMF_ERROR_PARSE as libc::c_int { try_optional = true; } else { - return r; + return Err(r); } } 17 => { r = mailimf_in_reply_to_parse(message, length, &mut cur_token, &mut in_reply_to); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::InReplyTo(in_reply_to); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::InReplyTo(in_reply_to)); } else if r == MAILIMF_ERROR_PARSE as libc::c_int { try_optional = true; } else { - return r; + return Err(r); } } 18 => { r = mailimf_references_parse(message, length, &mut cur_token, &mut references); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::References(references); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::References(references)); } else if r == MAILIMF_ERROR_PARSE as libc::c_int { try_optional = true; } else { - return r; + return Err(r); } } 19 => { r = mailimf_subject_parse(message, length, &mut cur_token, &mut subject); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::Subject(subject); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::Subject(subject)); } else if r == MAILIMF_ERROR_PARSE as libc::c_int { try_optional = true; } else { - return r; + return Err(r); } } 20 => { r = mailimf_comments_parse(message, length, &mut cur_token, &mut comments); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::Comments(comments); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::Comments(comments)); } else if r == MAILIMF_ERROR_PARSE as libc::c_int { try_optional = true; } else { - return r; + return Err(r); } } 21 => { r = mailimf_keywords_parse(message, length, &mut cur_token, &mut keywords); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::Keywords(keywords); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::Keywords(keywords)); } else if r == MAILIMF_ERROR_PARSE as libc::c_int { try_optional = true; } else { - return r; + return Err(r); } } 1 => { r = mailimf_return_parse(message, length, &mut cur_token, &mut return_path); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::ReturnPath(return_path); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::ReturnPath(return_path)); } else if r == MAILIMF_ERROR_PARSE as libc::c_int { try_optional = true; } else { - return r; + return Err(r); } } 2 => { r = mailimf_resent_date_parse(message, length, &mut cur_token, &mut resent_date); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::ResentDate(resent_date); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::ResentDate(resent_date)); } else if r == MAILIMF_ERROR_PARSE as libc::c_int { try_optional = true; } else { - return r; + return Err(r); } } 3 => { r = mailimf_resent_from_parse(message, length, &mut cur_token, &mut resent_from); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::ResentFrom(resent_from); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::ResentFrom(resent_from)); } else if r == MAILIMF_ERROR_PARSE as libc::c_int { try_optional = true; } else { - return r; + return Err(r); } } 4 => { r = mailimf_resent_sender_parse(message, length, &mut cur_token, &mut resent_sender); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::ResentSender(resent_sender); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::ResentSender(resent_sender)); } else if r == MAILIMF_ERROR_PARSE as libc::c_int { try_optional = true; } else { - return r; + return Err(r); } } 5 => { r = mailimf_resent_to_parse(message, length, &mut cur_token, &mut resent_to); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::ResentTo(resent_to); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::ResentTo(resent_to)); } else if r == MAILIMF_ERROR_PARSE as libc::c_int { try_optional = true; } else { - return r; + return Err(r); } } 6 => { r = mailimf_resent_cc_parse(message, length, &mut cur_token, &mut resent_cc); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::ResentCc(resent_cc); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::ResentCc(resent_cc)); } else if r == MAILIMF_ERROR_PARSE as libc::c_int { try_optional = true; } else { - return r; + return Err(r); } } 7 => { r = mailimf_resent_bcc_parse(message, length, &mut cur_token, &mut resent_bcc); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::ResentBcc(resent_bcc); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::ResentBcc(resent_bcc)); } else if r == MAILIMF_ERROR_PARSE as libc::c_int { try_optional = true; } else { - return r; + return Err(r); } } 8 => { r = mailimf_resent_msg_id_parse(message, length, &mut cur_token, &mut resent_msg_id); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::ResentMsgId(resent_msg_id); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::ResentMsgId(resent_msg_id)); } else if r == MAILIMF_ERROR_PARSE as libc::c_int { try_optional = true; } else { - return r; + return Err(r); } } _ => { @@ -543,14 +521,13 @@ unsafe fn mailimf_field_parse( if try_optional { r = mailimf_optional_field_parse(message, length, &mut cur_token, &mut optional_field); if r != MAILIMF_NO_ERROR as libc::c_int { - return r; + return Err(r); } - *result = mailimf_field::OptionalField(optional_field); *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + return Ok(mailimf_field::OptionalField(optional_field)); } - res + Err(res) } unsafe fn mailimf_optional_field_parse( @@ -1131,7 +1108,7 @@ unsafe fn mailimf_resent_msg_id_parse( } } } - return res; + res } pub unsafe fn mailimf_msg_id_parse( @@ -3890,7 +3867,7 @@ pub unsafe fn mailimf_msg_id_list_parse( indx, result, Some(mailimf_unstrict_msg_id_parse), - Some(mailimf_msg_id_free), + Some(|f| mailimf_msg_id_free(*f)), ) } @@ -3898,33 +3875,32 @@ unsafe fn mailimf_unstrict_msg_id_parse( message: *const libc::c_char, length: size_t, indx: *mut size_t, - result: &mut *mut libc::c_char, -) -> libc::c_int { +) -> Result<*mut libc::c_char, libc::c_int> { let mut msgid: *mut libc::c_char = 0 as *mut libc::c_char; let mut cur_token: size_t = 0; let mut r: libc::c_int = 0; cur_token = *indx; r = mailimf_cfws_parse(message, length, &mut cur_token); if r != MAILIMF_NO_ERROR as libc::c_int && r != MAILIMF_ERROR_PARSE as libc::c_int { - return r; + return Err(r); } r = mailimf_parse_unwanted_msg_id(message, length, &mut cur_token); if r != MAILIMF_NO_ERROR as libc::c_int { - return r; + return Err(r); } r = mailimf_msg_id_parse(message, length, &mut cur_token, &mut msgid); if r != MAILIMF_NO_ERROR as libc::c_int { - return r; + return Err(r); } r = mailimf_parse_unwanted_msg_id(message, length, &mut cur_token); if r != MAILIMF_NO_ERROR as libc::c_int { free(msgid as *mut libc::c_void); - return r; + return Err(r); } - *result = msgid; *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; + Ok(msgid) } + unsafe fn mailimf_parse_unwanted_msg_id( mut message: *const libc::c_char, mut length: size_t, @@ -4171,55 +4147,52 @@ unsafe fn mailimf_struct_multiple_parse( mut indx: *mut size_t, mut result: &mut Vec, mut parser: Option< - unsafe fn(_: *const libc::c_char, _: size_t, _: *mut size_t, _: &mut T) -> libc::c_int, + unsafe fn(_: *const libc::c_char, _: size_t, _: *mut size_t) -> Result, >, - mut destructor: Option, + mut destructor: Option, ) -> libc::c_int { let mut current_block: u64; let mut struct_list = Vec::new(); let mut cur_token: size_t = 0; - let mut value: T; let mut r: libc::c_int = 0; let mut res: libc::c_int = 0; cur_token = *indx; - r = parser.expect("non-null function pointer")(message, length, &mut cur_token, &mut value); - if r != MAILIMF_NO_ERROR as libc::c_int { - res = r - } else { - struct_list.push(value); - loop { - r = parser.expect("non-null function pointer")( - message, - length, - &mut cur_token, - &mut value, - ); - if r != MAILIMF_NO_ERROR as libc::c_int { - if r == MAILIMF_ERROR_PARSE as libc::c_int { - current_block = 11057878835866523405; - break; - } - res = r; - current_block = 8222683242185098763; - break; - } else { - struct_list.push(value); - continue; - } - } - match current_block { - 8222683242185098763 => {} - _ => { - *result = struct_list; - *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; - } - } - if let Some(destructor) = destructor { - for el in &struct_list { - destructor(*el); + match parser.expect("non-null function pointer")(message, length, &mut cur_token) { + Err(err) => res = err, + Ok(value) => { + struct_list.push(value); + loop { + match parser.expect("non-null function pointer")(message, length, &mut cur_token) { + Err(r) => { + if r == MAILIMF_ERROR_PARSE as libc::c_int { + current_block = 11057878835866523405; + break; + } + res = r; + current_block = 8222683242185098763; + break; + } + Ok(value) => { + struct_list.push(value); + continue; + } + } + } + match current_block { + 8222683242185098763 => {} + _ => { + *result = struct_list; + *indx = cur_token; + return MAILIMF_NO_ERROR as libc::c_int; + } + } + + if let Some(destructor) = destructor { + for el in &struct_list { + destructor(el); + } } } } @@ -4886,38 +4859,41 @@ pub unsafe fn mailimf_envelope_fields_parse( let mut list = Vec::new(); loop { - let mut elt: mailimf_field; - r = mailimf_envelope_field_parse(message, length, &mut cur_token, &mut elt); - if r == MAILIMF_NO_ERROR as libc::c_int { - list.push(elt); - continue; - } else if r == MAILIMF_ERROR_PARSE as libc::c_int { - r = mailimf_ignore_field_parse(message, length, &mut cur_token); - if r == MAILIMF_NO_ERROR as libc::c_int { + match mailimf_envelope_field_parse(message, length, &mut cur_token) { + Ok(elt) => { + list.push(elt); continue; } - /* do nothing */ - if r == MAILIMF_ERROR_PARSE as libc::c_int { - current_block = 2719512138335094285; - break; + Err(mut r) => { + if r == MAILIMF_ERROR_PARSE as libc::c_int { + r = mailimf_ignore_field_parse(message, length, &mut cur_token); + if r == MAILIMF_NO_ERROR as libc::c_int { + continue; + } + /* do nothing */ + if r == MAILIMF_ERROR_PARSE as libc::c_int { + current_block = 2719512138335094285; + break; + } + res = r; + current_block = 894413572976700158; + break; + } else { + res = r; + current_block = 894413572976700158; + break; + } + match current_block { + 2719512138335094285 => { + *result = mailimf_fields_new(list); + *indx = cur_token; + return MAILIMF_NO_ERROR as libc::c_int; + } + _ => {} + } } - res = r; - current_block = 894413572976700158; - break; - } else { - res = r; - current_block = 894413572976700158; - break; } } - match current_block { - 2719512138335094285 => { - *result = mailimf_fields_new(list); - *indx = cur_token; - return MAILIMF_NO_ERROR as libc::c_int; - } - _ => {} - } res } @@ -5032,10 +5008,7 @@ unsafe fn mailimf_envelope_field_parse( message: *const libc::c_char, length: size_t, indx: *mut size_t, - result: &mut mailimf_field, -) -> libc::c_int { - let mut cur_token: size_t = 0; - let mut type_0: libc::c_int = 0; +) -> Result { let mut orig_date: *mut mailimf_orig_date = 0 as *mut mailimf_orig_date; let mut from: *mut mailimf_from = 0 as *mut mailimf_from; let mut sender: *mut mailimf_sender = 0 as *mut mailimf_sender; @@ -5049,97 +5022,94 @@ unsafe fn mailimf_envelope_field_parse( let mut subject: *mut mailimf_subject = 0 as *mut mailimf_subject; let mut optional_field: *mut mailimf_optional_field = 0 as *mut mailimf_optional_field; - let mut r = 0; - let mut cur_token = *indx; let guessed_type = guess_header_type(message, length, cur_token); - - let mut try_optional = false; + let mut r = 0; match guessed_type { 9 => { r = mailimf_orig_date_parse(message, length, &mut cur_token, &mut orig_date); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::OrigDate(orig_date); *indx = cur_token; + return Ok(mailimf_field::OrigDate(orig_date)); } } 10 => { r = mailimf_from_parse(message, length, &mut cur_token, &mut from); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::From(from); *indx = cur_token; + return Ok(mailimf_field::From(from)); } } 11 => { r = mailimf_sender_parse(message, length, &mut cur_token, &mut sender); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::Sender(sender); *indx = cur_token; + return Ok(mailimf_field::Sender(sender)); } } 12 => { r = mailimf_reply_to_parse(message, length, &mut cur_token, &mut reply_to); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::ReplyTo(reply_to); *indx = cur_token; + return Ok(mailimf_field::ReplyTo(reply_to)); } } 13 => { r = mailimf_to_parse(message, length, &mut cur_token, &mut to); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::To(to); *indx = cur_token; + return Ok(mailimf_field::To(to)); } } 14 => { r = mailimf_cc_parse(message, length, &mut cur_token, &mut cc); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::Cc(cc); *indx = cur_token; + return Ok(mailimf_field::Cc(cc)); } } 15 => { r = mailimf_bcc_parse(message, length, &mut cur_token, &mut bcc); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::Bcc(bcc); *indx = cur_token; + return Ok(mailimf_field::Bcc(bcc)); } } 16 => { r = mailimf_message_id_parse(message, length, &mut cur_token, &mut message_id); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::MessageId(message_id); *indx = cur_token; + return Ok(mailimf_field::MessageId(message_id)); } } 17 => { r = mailimf_in_reply_to_parse(message, length, &mut cur_token, &mut in_reply_to); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::InReplyTo(in_reply_to); *indx = cur_token; + return Ok(mailimf_field::InReplyTo(in_reply_to)); } } 18 => { r = mailimf_references_parse(message, length, &mut cur_token, &mut references); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::References(references); *indx = cur_token; + return Ok(mailimf_field::References(references)); } } 19 => { r = mailimf_subject_parse(message, length, &mut cur_token, &mut subject); if r == MAILIMF_NO_ERROR as libc::c_int { - *result = mailimf_field::Subject(subject); *indx = cur_token; + return Ok(mailimf_field::Subject(subject)); } } _ => { - r = MAILIMF_ERROR_PARSE as libc::c_int; + return Err(MAILIMF_ERROR_PARSE as libc::c_int); } } - r + Err(r) } /* @@ -5210,25 +5180,22 @@ unsafe fn mailimf_envelope_or_optional_field_parse( message: *const libc::c_char, length: size_t, indx: *mut size_t, - result: &mut mailimf_field, -) -> libc::c_int { - let mut r: libc::c_int = 0; - let mut cur_token: size_t = 0; - let mut optional_field: *mut mailimf_optional_field = 0 as *mut mailimf_optional_field; - let mut field: *mut mailimf_field = 0 as *mut mailimf_field; - r = mailimf_envelope_field_parse(message, length, indx, result); - if r == MAILIMF_NO_ERROR as libc::c_int { - return MAILIMF_NO_ERROR as libc::c_int; - } - cur_token = *indx; - r = mailimf_optional_field_parse(message, length, &mut cur_token, &mut optional_field); - if r != MAILIMF_NO_ERROR as libc::c_int { - return r; - } +) -> Result { + match mailimf_envelope_field_parse(message, length, indx) { + Ok(value) => Ok(value), + Err(_) => { + let mut optional_field: *mut mailimf_optional_field = 0 as *mut mailimf_optional_field; + let mut cur_token = *indx; + let r = + mailimf_optional_field_parse(message, length, &mut cur_token, &mut optional_field); + if r != MAILIMF_NO_ERROR as libc::c_int { + return Err(r); + } - *result = mailimf_field::OptionalField(optional_field); - *indx = cur_token; - MAILIMF_NO_ERROR as libc::c_int + *indx = cur_token; + Ok(mailimf_field::OptionalField(optional_field)) + } + } } /* @@ -5296,20 +5263,17 @@ unsafe fn mailimf_only_optional_field_parse( message: *const libc::c_char, length: size_t, indx: *mut size_t, - result: &mut mailimf_field, -) -> libc::c_int { - let mut r: libc::c_int = 0; - let mut cur_token: size_t = 0; +) -> Result { let mut optional_field = std::ptr::null_mut(); - cur_token = *indx; - r = mailimf_optional_field_parse(message, length, &mut cur_token, &mut optional_field); + let mut cur_token = *indx; + + let r = mailimf_optional_field_parse(message, length, &mut cur_token, &mut optional_field); if r != MAILIMF_NO_ERROR as libc::c_int { - return r; + return Err(r); } - *result = mailimf_field::OptionalField(optional_field); *indx = cur_token; - MAILIMF_NO_ERROR as libc::c_int + Ok(mailimf_field::OptionalField(optional_field)) } pub unsafe fn mailimf_custom_string_parse( diff --git a/mmime/src/mailimf/types.rs b/mmime/src/mailimf/types.rs index 79832546e..fed2aa26e 100644 --- a/mmime/src/mailimf/types.rs +++ b/mmime/src/mailimf/types.rs @@ -171,7 +171,7 @@ impl Drop for mailimf_field { unsafe { match self { ReturnPath(p) => mailimf_return_free(*p), - OrigDate(d) => mailimf_orig_date_free(*d), + ResentDate(d) => mailimf_orig_date_free(*d), ResentFrom(r) => mailimf_from_free(*r), ResentSender(r) => mailimf_sender_free(*r), ResentTo(r) => mailimf_to_free(*r), @@ -929,8 +929,9 @@ pub unsafe fn mailimf_optional_field_new( } (*opt_field).fld_name = fld_name; (*opt_field).fld_value = fld_value; - return opt_field; + opt_field } + /* internal use */ #[no_mangle] pub unsafe fn mailimf_atom_free(mut atom: *mut libc::c_char) { diff --git a/mmime/src/mailimf/types_helper.rs b/mmime/src/mailimf/types_helper.rs index 5b34dcdb7..16ca06423 100644 --- a/mmime/src/mailimf/types_helper.rs +++ b/mmime/src/mailimf/types_helper.rs @@ -1,6 +1,4 @@ -use crate::clist::*; use crate::mailimf::types::*; -use crate::other::*; /* this function creates a new mailimf_fields structure with no fields @@ -15,20 +13,8 @@ pub unsafe fn mailimf_fields_new_empty() -> *mut mailimf_fields { @return MAILIMF_NO_ERROR will be returned on success, other code will be returned otherwise */ -pub unsafe fn mailimf_fields_add( - mut fields: *mut mailimf_fields, - mut field: *mut mailimf_field, -) -> libc::c_int { - let mut r: libc::c_int = 0; - r = clist_insert_after( - (*fields).fld_list, - (*(*fields).fld_list).last, - field as *mut libc::c_void, - ); - if r < 0i32 { - return MAILIMF_ERROR_MEMORY as libc::c_int; - } - return MAILIMF_NO_ERROR as libc::c_int; +pub unsafe fn mailimf_fields_add(fields: *mut mailimf_fields, field: mailimf_field) { + (*fields).0.push(field) } /* @@ -38,19 +24,11 @@ pub unsafe fn mailimf_fields_add( @param value should be allocated with malloc() */ pub unsafe fn mailimf_field_new_custom( - mut name: *mut libc::c_char, - mut value: *mut libc::c_char, -) -> *mut mailimf_field { - let mut opt_field: *mut mailimf_optional_field = 0 as *mut mailimf_optional_field; - let mut field: *mut mailimf_field = 0 as *mut mailimf_field; - opt_field = mailimf_optional_field_new(name, value); - if !opt_field.is_null() { - field = mailimf_field::OptionalField(opt_field); - if field.is_null() { - mailimf_optional_field_free(opt_field); - } else { - return field; - } - } - return 0 as *mut mailimf_field; + name: *mut libc::c_char, + value: *mut libc::c_char, +) -> mailimf_field { + let opt_field = mailimf_optional_field_new(name, value); + assert!(!opt_field.is_null(), "failed memory allocation"); + + mailimf_field::OptionalField(opt_field) } diff --git a/mmime/src/mailimf/write_generic.rs b/mmime/src/mailimf/write_generic.rs index 32a59fadb..f0ed1cc94 100644 --- a/mmime/src/mailimf/write_generic.rs +++ b/mmime/src/mailimf/write_generic.rs @@ -166,35 +166,19 @@ pub unsafe fn mailimf_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, + data: *mut libc::c_void, + col: *mut libc::c_int, + 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; - r = mailimf_field_write_driver( - do_write, - data, - col, - (if !cur.is_null() { - (*cur).data - } else { - 0 as *mut libc::c_void - }) as *mut mailimf_field, - ); + for cur in &(*fields).0 { + let r = mailimf_field_write_driver(do_write, data, col, cur); 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; + MAILIMF_NO_ERROR as libc::c_int } + /* mailimf_field_write writes a field to a given stream @@ -207,118 +191,38 @@ pub unsafe fn mailimf_field_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 field: *mut mailimf_field, + data: *mut libc::c_void, + col: *mut libc::c_int, + field: &mailimf_field, ) -> libc::c_int { - let mut r: libc::c_int = 0; - match (*field).fld_type { - 1 => { - r = mailimf_return_write_driver(do_write, data, col, (*field).fld_data.fld_return_path) - } - 2 => { - r = mailimf_resent_date_write_driver( - do_write, - data, - col, - (*field).fld_data.fld_resent_date, - ) - } - 3 => { - r = mailimf_resent_from_write_driver( - do_write, - data, - col, - (*field).fld_data.fld_resent_from, - ) - } - 4 => { - r = mailimf_resent_sender_write_driver( - do_write, - data, - col, - (*field).fld_data.fld_resent_sender, - ) - } - 5 => { - r = mailimf_resent_to_write_driver(do_write, data, col, (*field).fld_data.fld_resent_to) - } - 6 => { - r = mailimf_resent_cc_write_driver(do_write, data, col, (*field).fld_data.fld_resent_cc) - } - 7 => { - r = mailimf_resent_bcc_write_driver( - do_write, - data, - col, - (*field).fld_data.fld_resent_bcc, - ) - } - 8 => { - r = mailimf_resent_msg_id_write_driver( - do_write, - data, - col, - (*field).fld_data.fld_resent_msg_id, - ) - } - 9 => { - r = mailimf_orig_date_write_driver(do_write, data, col, (*field).fld_data.fld_orig_date) - } - 10 => r = mailimf_from_write_driver(do_write, data, col, (*field).fld_data.fld_from), - 11 => r = mailimf_sender_write_driver(do_write, data, col, (*field).fld_data.fld_sender), - 12 => { - r = mailimf_reply_to_write_driver(do_write, data, col, (*field).fld_data.fld_reply_to) - } - 13 => r = mailimf_to_write_driver(do_write, data, col, (*field).fld_data.fld_to), - 14 => r = mailimf_cc_write_driver(do_write, data, col, (*field).fld_data.fld_cc), - 15 => r = mailimf_bcc_write_driver(do_write, data, col, (*field).fld_data.fld_bcc), - 16 => { - r = mailimf_message_id_write_driver( - do_write, - data, - col, - (*field).fld_data.fld_message_id, - ) - } - 17 => { - r = mailimf_in_reply_to_write_driver( - do_write, - data, - col, - (*field).fld_data.fld_in_reply_to, - ) - } - 18 => { - r = mailimf_references_write_driver( - do_write, - data, - col, - (*field).fld_data.fld_references, - ) - } - 19 => r = mailimf_subject_write_driver(do_write, data, col, (*field).fld_data.fld_subject), - 20 => { - r = mailimf_comments_write_driver(do_write, data, col, (*field).fld_data.fld_comments) - } - 21 => { - r = mailimf_keywords_write_driver(do_write, data, col, (*field).fld_data.fld_keywords) - } - 22 => { - r = mailimf_optional_field_write_driver( - do_write, - data, - col, - (*field).fld_data.fld_optional_field, - ) - } - _ => r = MAILIMF_ERROR_INVAL as libc::c_int, + use mailimf_field::*; + + match field { + ReturnPath(path) => mailimf_return_write_driver(do_write, data, col, *path), + ResentDate(date) => mailimf_resent_date_write_driver(do_write, data, col, *date), + ResentFrom(from) => mailimf_resent_from_write_driver(do_write, data, col, *from), + ResentSender(sender) => mailimf_resent_sender_write_driver(do_write, data, col, *sender), + ResentTo(to) => mailimf_resent_to_write_driver(do_write, data, col, *to), + ResentCc(cc) => mailimf_resent_cc_write_driver(do_write, data, col, *cc), + ResentBcc(bcc) => mailimf_resent_bcc_write_driver(do_write, data, col, *bcc), + ResentMsgId(id) => mailimf_resent_msg_id_write_driver(do_write, data, col, *id), + OrigDate(date) => mailimf_orig_date_write_driver(do_write, data, col, *date), + From(from) => mailimf_from_write_driver(do_write, data, col, *from), + Sender(sender) => mailimf_sender_write_driver(do_write, data, col, *sender), + ReplyTo(to) => mailimf_reply_to_write_driver(do_write, data, col, *to), + To(to) => mailimf_to_write_driver(do_write, data, col, *to), + Cc(cc) => mailimf_cc_write_driver(do_write, data, col, *cc), + Bcc(bcc) => mailimf_bcc_write_driver(do_write, data, col, *bcc), + MessageId(id) => mailimf_message_id_write_driver(do_write, data, col, *id), + InReplyTo(to) => mailimf_in_reply_to_write_driver(do_write, data, col, *to), + References(refs) => mailimf_references_write_driver(do_write, data, col, *refs), + Subject(s) => mailimf_subject_write_driver(do_write, data, col, *s), + Comments(c) => mailimf_comments_write_driver(do_write, data, col, *c), + Keywords(k) => mailimf_keywords_write_driver(do_write, data, col, *k), + OptionalField(f) => mailimf_optional_field_write_driver(do_write, data, col, *f), } - if r != MAILIMF_NO_ERROR as libc::c_int { - return r; - } - return MAILIMF_NO_ERROR as libc::c_int; } + unsafe fn mailimf_optional_field_write_driver( mut do_write: Option< unsafe fn(_: *mut libc::c_void, _: *const libc::c_char, _: size_t) -> libc::c_int, diff --git a/mmime/src/mailmime/content.rs b/mmime/src/mailmime/content.rs index f17a66e4a..eab3977f8 100644 --- a/mmime/src/mailmime/content.rs +++ b/mmime/src/mailmime/content.rs @@ -1251,13 +1251,13 @@ unsafe fn remove_unparsed_mime_headers(fields: *mut mailimf_fields) { mailimf_field::OptionalField(data) => { delete = false; if strncasecmp( - data.fld_name, + (**data).fld_name, b"Content-\x00" as *const u8 as *const libc::c_char, 8i32 as libc::size_t, ) == 0i32 { let mut name: *mut libc::c_char = 0 as *mut libc::c_char; - name = data.fld_name.offset(8isize); + name = (**data).fld_name.offset(8isize); if strcasecmp(name, b"Type\x00" as *const u8 as *const libc::c_char) == 0i32 || strcasecmp( name, @@ -1274,7 +1274,7 @@ unsafe fn remove_unparsed_mime_headers(fields: *mut mailimf_fields) { delete = true; } } else if strcasecmp( - data.fld_name, + (**data).fld_name, b"MIME-Version\x00" as *const u8 as *const libc::c_char, ) == 0i32 { diff --git a/mmime/src/mailmime/mod.rs b/mmime/src/mailmime/mod.rs index d13fe4bdd..69749a58e 100644 --- a/mmime/src/mailmime/mod.rs +++ b/mmime/src/mailmime/mod.rs @@ -1068,8 +1068,6 @@ pub unsafe fn mailmime_fields_parse( mut fields: *mut mailimf_fields, mut result: *mut *mut mailmime_fields, ) -> libc::c_int { - let mut current_block: u64; - let mut cur: *mut clistiter = 0 as *mut clistiter; let mut mime_fields: *mut mailmime_fields = 0 as *mut mailmime_fields; let mut list: *mut clist = 0 as *mut clist; let mut r: libc::c_int = 0; @@ -1078,58 +1076,27 @@ pub unsafe fn mailmime_fields_parse( if list.is_null() { res = MAILIMF_ERROR_MEMORY as libc::c_int } else { - cur = (*(*fields).fld_list).first; - loop { - if cur.is_null() { - current_block = 1109700713171191020; - break; - } - let mut field: *mut mailimf_field = 0 as *mut mailimf_field; - let mut mime_field: *mut mailmime_field = 0 as *mut mailmime_field; - field = (if !cur.is_null() { - (*cur).data - } else { - 0 as *mut libc::c_void - }) as *mut mailimf_field; - if (*field).fld_type == MAILIMF_FIELD_OPTIONAL_FIELD as libc::c_int { - r = mailmime_field_parse((*field).fld_data.fld_optional_field, &mut mime_field); + for field in &(*fields).0 { + let mut mime_field = 0 as *mut mailmime_field; + + if let mailimf_field::OptionalField(opt_field) = field { + r = mailmime_field_parse(*opt_field, &mut mime_field); + if r == MAILIMF_NO_ERROR as libc::c_int { r = clist_insert_after(list, (*list).last, mime_field as *mut libc::c_void); if r < 0i32 { mailmime_field_free(mime_field); res = MAILIMF_ERROR_MEMORY as libc::c_int; - current_block = 17592539310030730040; break; } } else if !(r == MAILIMF_ERROR_PARSE as libc::c_int) { /* do nothing */ res = r; - current_block = 17592539310030730040; break; } } - cur = if !cur.is_null() { - (*cur).next - } else { - 0 as *mut clistcell - } - } - match current_block { - 1109700713171191020 => { - if (*list).first.is_null() { - res = MAILIMF_ERROR_PARSE as libc::c_int - } else { - mime_fields = mailmime_fields_new(list); - if mime_fields.is_null() { - res = MAILIMF_ERROR_MEMORY as libc::c_int - } else { - *result = mime_fields; - return MAILIMF_NO_ERROR as libc::c_int; - } - } - } - _ => {} } + clist_foreach( list, ::std::mem::transmute:: ()>, clist_func>( diff --git a/mmime/src/other.rs b/mmime/src/other.rs index 1741c5858..9509c39a5 100644 --- a/mmime/src/other.rs +++ b/mmime/src/other.rs @@ -450,12 +450,8 @@ pub unsafe fn mailimf_fields_add_data( current_block = 16539016819803454162; } else { let field = mailimf_field::OrigDate(imf_date); - r = mailimf_fields_add(fields, field); - if r != MAILIMF_NO_ERROR as libc::c_int { - current_block = 13813460800808168376; - } else { - current_block = 2719512138335094285; - } + mailimf_fields_add(fields, field); + current_block = 2719512138335094285; } } else { current_block = 2719512138335094285; @@ -468,12 +464,8 @@ pub unsafe fn mailimf_fields_add_data( current_block = 13813460800808168376; } else { let field = mailimf_field::From(imf_from); - r = mailimf_fields_add(fields, field); - if r != MAILIMF_NO_ERROR as libc::c_int { - current_block = 13813460800808168376; - } else { - current_block = 3275366147856559585; - } + mailimf_fields_add(fields, field); + current_block = 3275366147856559585; } } else { current_block = 3275366147856559585; @@ -488,12 +480,8 @@ pub unsafe fn mailimf_fields_add_data( current_block = 16539016819803454162; } else { let field = mailimf_field::Sender(imf_sender); - r = mailimf_fields_add(fields, field); - if r != MAILIMF_NO_ERROR as libc::c_int { - current_block = 13813460800808168376; - } else { - current_block = 15090052786889560393; - } + mailimf_fields_add(fields, field); + current_block = 15090052786889560393; } } else { current_block = 15090052786889560393; @@ -508,12 +496,8 @@ pub unsafe fn mailimf_fields_add_data( current_block = 16539016819803454162; } else { let field = mailimf_field::ReplyTo(imf_reply_to); - r = mailimf_fields_add(fields, field); - if r != MAILIMF_NO_ERROR as libc::c_int { - current_block = 13813460800808168376; - } else { - current_block = 10150597327160359210; - } + mailimf_fields_add(fields, field); + current_block = 10150597327160359210; } } else { current_block = 10150597327160359210; @@ -528,12 +512,8 @@ pub unsafe fn mailimf_fields_add_data( current_block = 16539016819803454162; } else { let field = mailimf_field::To(imf_to); - r = mailimf_fields_add(fields, field); - if r != MAILIMF_NO_ERROR as libc::c_int { - current_block = 13813460800808168376; - } else { - current_block = 17233182392562552756; - } + mailimf_fields_add(fields, field); + current_block = 17233182392562552756; } } else { current_block = 17233182392562552756; @@ -548,12 +528,8 @@ pub unsafe fn mailimf_fields_add_data( current_block = 16539016819803454162; } else { let field = mailimf_field::Cc(imf_cc); - r = mailimf_fields_add(fields, field); - if r != MAILIMF_NO_ERROR as libc::c_int { - current_block = 13813460800808168376; - } else { - current_block = 12930649117290160518; - } + mailimf_fields_add(fields, field); + current_block = 12930649117290160518; } } else { current_block = 12930649117290160518; @@ -568,14 +544,8 @@ pub unsafe fn mailimf_fields_add_data( current_block = 16539016819803454162; } else { let field = mailimf_field::Bcc(imf_bcc); - r = mailimf_fields_add(fields, field); - if r != MAILIMF_NO_ERROR as libc::c_int - { - current_block = - 13813460800808168376; - } else { - current_block = 7858101417678297991; - } + mailimf_fields_add(fields, field); + current_block = 7858101417678297991; } } else { current_block = 7858101417678297991; @@ -595,18 +565,11 @@ pub unsafe fn mailimf_fields_add_data( mailimf_field::MessageId( imf_msg_id, ); - r = mailimf_fields_add( + mailimf_fields_add( fields, field, ); - if r != MAILIMF_NO_ERROR - as libc::c_int - { - current_block = - 13813460800808168376; - } else { - current_block = - 15514718523126015390; - } + current_block = + 15514718523126015390; } } else { current_block = @@ -632,20 +595,12 @@ pub unsafe fn mailimf_fields_add_data( mailimf_field::InReplyTo( imf_in_reply_to, ); - r = mailimf_fields_add( + mailimf_fields_add( fields, field, ); - if r != MAILIMF_NO_ERROR - as libc::c_int - { - current_block - = - 13813460800808168376; - } else { - current_block + current_block = 15587532755333643506; - } } } else { current_block = @@ -671,25 +626,10 @@ pub unsafe fn mailimf_fields_add_data( = mailimf_field::References( imf_references); - r - = - mailimf_fields_add(fields, - field); - if r - != - MAILIMF_NO_ERROR - as - libc::c_int - { - current_block - = - 13813460800808168376; - } else { - current_block - = - 7301440000599063274; - - } + mailimf_fields_add(fields, field); + current_block + = + 7301440000599063274; } } else { current_block @@ -722,17 +662,10 @@ pub unsafe fn mailimf_fields_add_data( } else { let field = mailimf_field::Subject(imf_subject); - r = mailimf_fields_add(fields, field); - if r != MAILIMF_NO_ERROR as libc::c_int - { - current_block - = - 13813460800808168376; - } else { - current_block - = - 10153752038087260855; - } + mailimf_fields_add(fields, field); + current_block + = + 10153752038087260855; } } else { current_block @@ -791,7 +724,7 @@ pub unsafe fn mailimf_fields_add_data( imf_references, imf_subject, ); - MAILIMF_ERROR_MEMORY + MAILIMF_ERROR_MEMORY as libc::c_int } unsafe fn detach_free_fields(