From 2abfd037cac9effca84d67a0740d34c14ac4fc43 Mon Sep 17 00:00:00 2001 From: dignifiedquire Date: Sat, 28 Sep 2019 13:31:12 -0600 Subject: [PATCH] refactor(mmime): rustify mailmime_address --- mmime/src/display.rs | 16 +++--- mmime/src/mailimf/mod.rs | 56 ++++++++------------ mmime/src/mailimf/types.rs | 83 +++++++++++------------------- mmime/src/mailimf/write_generic.rs | 16 +++--- src/dc_mimeparser.rs | 25 +++++---- src/dc_receive_imf.rs | 28 ++++------ src/mimefactory.rs | 20 +++---- 7 files changed, 99 insertions(+), 145 deletions(-) diff --git a/mmime/src/display.rs b/mmime/src/display.rs index 8851c4eb5..ddec53bd0 100644 --- a/mmime/src/display.rs +++ b/mmime/src/display.rs @@ -278,17 +278,17 @@ unsafe fn display_group(mut group: *mut mailimf_group) { } print!("; "); } -unsafe fn display_address(mut a: *mut mailimf_address) { - match (*a).ad_type { - 2 => { - display_group((*a).ad_data.ad_group); +unsafe fn display_address(a: *mut mailimf_address) { + match *a { + mailimf_address::Group(data) => { + display_group(data); } - 1 => { - display_mailbox((*a).ad_data.ad_mailbox); + mailimf_address::Mailbox(data) => { + display_mailbox(data); } - _ => {} - }; + } } + unsafe fn display_address_list(mut addr_list: *mut mailimf_address_list) { let mut cur: *mut clistiter = 0 as *mut clistiter; cur = (*(*addr_list).ad_list).first; diff --git a/mmime/src/mailimf/mod.rs b/mmime/src/mailimf/mod.rs index 5740b6c40..153fb33ac 100644 --- a/mmime/src/mailimf/mod.rs +++ b/mmime/src/mailimf/mod.rs @@ -1665,52 +1665,38 @@ pub unsafe fn mailimf_address_list_parse( @return MAILIMF_NO_ERROR on success, MAILIMF_ERROR_XXX on error */ pub unsafe fn mailimf_address_parse( - mut message: *const libc::c_char, - mut length: size_t, - mut indx: *mut size_t, - mut result: *mut *mut mailimf_address, + message: *const libc::c_char, + length: size_t, + indx: *mut size_t, + result: *mut *mut mailimf_address, ) -> libc::c_int { - let mut type_0: libc::c_int = 0; - let mut cur_token: size_t = 0; - let mut mailbox: *mut mailimf_mailbox = 0 as *mut mailimf_mailbox; - let mut group: *mut mailimf_group = 0 as *mut mailimf_group; - let mut address: *mut mailimf_address = 0 as *mut mailimf_address; - let mut r: libc::c_int = 0; - let mut res: libc::c_int = 0; - cur_token = *indx; - mailbox = 0 as *mut mailimf_mailbox; - group = 0 as *mut mailimf_group; - type_0 = MAILIMF_ADDRESS_ERROR as libc::c_int; - r = mailimf_group_parse(message, length, &mut cur_token, &mut group); + let mut mailbox = std::ptr::null_mut(); + let mut group = std::ptr::null_mut(); + let mut cur_token = *indx; + + let mut r = mailimf_group_parse(message, length, &mut cur_token, &mut group); + if r == MAILIMF_NO_ERROR as libc::c_int { - type_0 = MAILIMF_ADDRESS_GROUP as libc::c_int + // Valid group address + *indx = cur_token; + *result = mailimf_address_new_group(group); + return MAILIMF_NO_ERROR as libc::c_int; } + if r == MAILIMF_ERROR_PARSE as libc::c_int { r = mailimf_mailbox_parse(message, length, &mut cur_token, &mut mailbox); if r == MAILIMF_NO_ERROR as libc::c_int { - type_0 = MAILIMF_ADDRESS_MAILBOX as libc::c_int - } - } - if r != MAILIMF_NO_ERROR as libc::c_int { - res = r - } else { - address = mailimf_address_new(type_0, mailbox, group); - if address.is_null() { - res = MAILIMF_ERROR_MEMORY as libc::c_int; - if !mailbox.is_null() { - mailimf_mailbox_free(mailbox); - } - if !group.is_null() { - mailimf_group_free(group); - } - } else { - *result = address; + // Valid mailbox address *indx = cur_token; + mailimf_address_new_mailbox(mailbox); return MAILIMF_NO_ERROR as libc::c_int; } } - return res; + + // Cannot parse this address + r } + /* mailimf_mailbox_parse will parse the given address diff --git a/mmime/src/mailimf/types.rs b/mmime/src/mailimf/types.rs index b5e38cd80..c4f61321f 100644 --- a/mmime/src/mailimf/types.rs +++ b/mmime/src/mailimf/types.rs @@ -46,32 +46,14 @@ pub struct mailimf_date_time { /* if this is a group (group_name: address1@domain1, address2@domain2; ) */ -pub const MAILIMF_ADDRESS_GROUP: libc::c_uint = 2; -/* if this is a mailbox (mailbox@domain) */ -pub const MAILIMF_ADDRESS_MAILBOX: libc::c_uint = 1; -/* on parse error */ -pub const MAILIMF_ADDRESS_ERROR: libc::c_uint = 0; -/* - mailimf_address is an address - - type can be MAILIMF_ADDRESS_MAILBOX or MAILIMF_ADDRESS_GROUP - - - mailbox is a mailbox if type is MAILIMF_ADDRESS_MAILBOX - - - group is a group if type is MAILIMF_ADDRESS_GROUP -*/ -#[derive(Copy, Clone)] -#[repr(C)] -pub struct mailimf_address { - pub ad_type: libc::c_int, - pub ad_data: unnamed_0, -} -#[derive(Copy, Clone)] -#[repr(C)] -pub union unnamed_0 { - pub ad_mailbox: *mut mailimf_mailbox, - pub ad_group: *mut mailimf_group, +/// An address, either for a mailbox or a group. +#[derive(Debug, Clone, Copy)] +pub enum mailimf_address { + Mailbox(*mut mailimf_mailbox), + Group(*mut mailimf_group), } + /* mailimf_group is a group @@ -481,43 +463,40 @@ pub unsafe fn mailimf_date_time_new( (*date_time).dt_zone = dt_zone; return date_time; } -#[no_mangle] + pub unsafe fn mailimf_date_time_free(mut date_time: *mut mailimf_date_time) { free(date_time as *mut libc::c_void); } -#[no_mangle] -pub unsafe fn mailimf_address_new( - mut ad_type: libc::c_int, - mut ad_mailbox: *mut mailimf_mailbox, - mut ad_group: *mut mailimf_group, -) -> *mut mailimf_address { - let mut address: *mut mailimf_address = 0 as *mut mailimf_address; - address = - malloc(::std::mem::size_of::() as libc::size_t) as *mut mailimf_address; + +pub fn mailimf_address_new_mailbox(ad_mailbox: *mut mailimf_mailbox) -> *mut mailimf_address { + let addr = mailimf_address::Mailbox(ad_mailbox); + + Box::into_raw(Box::new(addr)) +} + +pub fn mailimf_address_new_group(ad_group: *mut mailimf_group) -> *mut mailimf_address { + let addr = mailimf_address::Group(ad_group); + + Box::into_raw(Box::new(addr)) +} + +pub unsafe fn mailimf_address_free(address: *mut mailimf_address) { if address.is_null() { - return 0 as *mut mailimf_address; + return; } - (*address).ad_type = ad_type; - match ad_type { - 1 => (*address).ad_data.ad_mailbox = ad_mailbox, - 2 => (*address).ad_data.ad_group = ad_group, - _ => {} - } - return address; -} -#[no_mangle] -pub unsafe fn mailimf_address_free(mut address: *mut mailimf_address) { - match (*address).ad_type { - 1 => { - mailimf_mailbox_free((*address).ad_data.ad_mailbox); + + let addr = Box::from_raw(address); + + match *addr { + mailimf_address::Mailbox(data) => { + mailimf_mailbox_free(data); } - 2 => { - mailimf_group_free((*address).ad_data.ad_group); + mailimf_address::Group(data) => { + mailimf_group_free(data); } - _ => {} } - free(address as *mut libc::c_void); } + #[no_mangle] pub unsafe fn mailimf_group_free(mut group: *mut mailimf_group) { if !(*group).grp_mb_list.is_null() { diff --git a/mmime/src/mailimf/write_generic.rs b/mmime/src/mailimf/write_generic.rs index 0d5328605..b9d8f6fba 100644 --- a/mmime/src/mailimf/write_generic.rs +++ b/mmime/src/mailimf/write_generic.rs @@ -972,24 +972,24 @@ unsafe fn mailimf_address_write_driver( mut col: *mut libc::c_int, mut addr: *mut mailimf_address, ) -> libc::c_int { - let mut r: libc::c_int = 0; - match (*addr).ad_type { - 1 => { - r = mailimf_mailbox_write_driver(do_write, data, col, (*addr).ad_data.ad_mailbox); + match *addr { + mailimf_address::Mailbox(mb_data) => { + let r = mailimf_mailbox_write_driver(do_write, data, col, mb_data); if r != MAILIMF_NO_ERROR as libc::c_int { return r; } } - 2 => { - r = mailimf_group_write_driver(do_write, data, col, (*addr).ad_data.ad_group); + mailimf_address::Group(gr_data) => { + let r = mailimf_group_write_driver(do_write, data, col, gr_data); if r != MAILIMF_NO_ERROR as libc::c_int { return r; } } - _ => {} } - return MAILIMF_NO_ERROR as libc::c_int; + + MAILIMF_NO_ERROR as libc::c_int } + unsafe fn mailimf_group_write_driver( mut do_write: Option< unsafe fn(_: *mut libc::c_void, _: *const libc::c_char, _: size_t) -> libc::c_int, diff --git a/src/dc_mimeparser.rs b/src/dc_mimeparser.rs index 02c915fe9..3dfefc362 100644 --- a/src/dc_mimeparser.rs +++ b/src/dc_mimeparser.rs @@ -1252,20 +1252,19 @@ pub fn mailimf_get_recipients(imffields: *mut mailimf_fields) -> HashSet if adr.is_null() { continue; } - let adr = unsafe { *adr }; - if adr.ad_type == MAILIMF_ADDRESS_MAILBOX as libc::c_int { - mailimf_get_recipients_add_addr(&mut recipients, unsafe { - adr.ad_data.ad_mailbox - }); - } else if adr.ad_type == MAILIMF_ADDRESS_GROUP as libc::c_int { - let group = unsafe { adr.ad_data.ad_group }; - if !group.is_null() && unsafe { !(*group).grp_mb_list.is_null() } { - for cur3 in unsafe { &(*(*(*group).grp_mb_list).mb_list) } { - mailimf_get_recipients_add_addr( - &mut recipients, - cur3 as *mut mailimf_mailbox, - ); + match unsafe { *adr } { + mailimf_address::Mailbox(mailbox) => { + mailimf_get_recipients_add_addr(&mut recipients, mailbox); + } + mailimf_address::Group(group) => { + if !group.is_null() && unsafe { !(*group).grp_mb_list.is_null() } { + for cur3 in unsafe { &(*(*(*group).grp_mb_list).mb_list) } { + mailimf_get_recipients_add_addr( + &mut recipients, + cur3 as *mut mailimf_mailbox, + ); + } } } } diff --git a/src/dc_receive_imf.rs b/src/dc_receive_imf.rs index e7d5d1db3..48aa1a2f7 100644 --- a/src/dc_receive_imf.rs +++ b/src/dc_receive_imf.rs @@ -1856,16 +1856,15 @@ unsafe fn dc_add_or_lookup_contacts_by_address_list( if adr_list.is_null() { return; } - let mut cur: *mut clistiter = (*(*adr_list).ad_list).first; - while !cur.is_null() { - let adr: *mut mailimf_address = (if !cur.is_null() { - (*cur).data - } else { - ptr::null_mut() - }) as *mut mailimf_address; - if !adr.is_null() { - if (*adr).ad_type == MAILIMF_ADDRESS_MAILBOX as libc::c_int { - let mb: *mut mailimf_mailbox = (*adr).ad_data.ad_mailbox; + + for cur in &(*(*adr_list).ad_list) { + let adr = cur as *mut mailimf_address; + if adr.is_null() { + continue; + } + + match *adr { + mailimf_address::Mailbox(mb) => { if !mb.is_null() { add_or_lookup_contact_by_addr( context, @@ -1876,8 +1875,8 @@ unsafe fn dc_add_or_lookup_contacts_by_address_list( check_self, ); } - } else if (*adr).ad_type == MAILIMF_ADDRESS_GROUP as libc::c_int { - let group: *mut mailimf_group = (*adr).ad_data.ad_group; + } + mailimf_address::Group(group) => { if !group.is_null() && !(*group).grp_mb_list.is_null() { dc_add_or_lookup_contacts_by_mailbox_list( context, @@ -1889,11 +1888,6 @@ unsafe fn dc_add_or_lookup_contacts_by_address_list( } } } - cur = if !cur.is_null() { - (*cur).next - } else { - ptr::null_mut() - } } } diff --git a/src/mimefactory.rs b/src/mimefactory.rs index 626b290a8..bd7c7b2cb 100644 --- a/src/mimefactory.rs +++ b/src/mimefactory.rs @@ -173,18 +173,14 @@ impl<'a> MimeFactory<'a> { for (name, addr) in name_iter.zip(addr_iter) { mailimf_address_list_add( to, - mailimf_address_new( - MAILIMF_ADDRESS_MAILBOX as libc::c_int, - mailimf_mailbox_new( - if !name.is_empty() { - dc_encode_header_words(&name).strdup() - } else { - ptr::null_mut() - }, - addr.strdup(), - ), - ptr::null_mut(), - ), + mailimf_address_new_mailbox(mailimf_mailbox_new( + if !name.is_empty() { + dc_encode_header_words(&name).strdup() + } else { + ptr::null_mut() + }, + addr.strdup(), + )), ); } }