refactor(mmime): rustify mailbox_list

mmime/src/display.rs

@@ -230,55 +230,26 @@ unsafe fn display_mailbox(mut mb: *mut mailimf_mailbox) {
     print!("<{}>", CStr::from_ptr((*mb).mb_addr_spec).to_str().unwrap());
 }
 unsafe fn display_mailbox_list(mut mb_list: *mut mailimf_mailbox_list) {
-    let mut cur: *mut clistiter = 0 as *mut clistiter;
+    for (i, mb) in (*mb_list).0.iter().enumerate() {
-    cur = (*(*mb_list).mb_list).first;
+        display_mailbox(*mb);
-    while !cur.is_null() {
+        if i < (*mb_list).0.len() - 1 {
-        let mut mb: *mut mailimf_mailbox = 0 as *mut mailimf_mailbox;
-        mb = (if !cur.is_null() {
-            (*cur).data
-        } else {
-            0 as *mut libc::c_void
-        }) as *mut mailimf_mailbox;
-        display_mailbox(mb);
-        if !if !cur.is_null() {
-            (*cur).next
-        } else {
-            0 as *mut clistcell
-        }
-        .is_null()
-        {
             print!(", ");
         }
-        cur = if !cur.is_null() {
-            (*cur).next
-        } else {
-            0 as *mut clistcell
-        }
     }
 }
+
 unsafe fn display_group(mut group: *mut mailimf_group) {
     let mut cur: *mut clistiter = 0 as *mut clistiter;
     print!(
         "{}: ",
         CStr::from_ptr((*group).display_name).to_str().unwrap()
     );
-    cur = (*(*(*group).mb_list).mb_list).first;
+    for mb in &(*(*group).mb_list).0 {
-    while !cur.is_null() {
+        display_mailbox(*mb);
-        let mut mb: *mut mailimf_mailbox = 0 as *mut mailimf_mailbox;
-        mb = (if !cur.is_null() {
-            (*cur).data
-        } else {
-            0 as *mut libc::c_void
-        }) as *mut mailimf_mailbox;
-        display_mailbox(mb);
-        cur = if !cur.is_null() {
-            (*cur).next
-        } else {
-            0 as *mut clistcell
-        }
     }
     print!("; ");
 }
+
 unsafe fn display_address(a: *mut mailimf_address) {
     match *a {
         mailimf_address::Group(data) => {

mmime/src/mailimf/types.rs

@@ -63,16 +63,18 @@ impl Drop for mailimf_group {
     }
 }
 
-/*
+/// A list of mailboxes
-  mailimf_mailbox_list is a list of mailboxes
+#[derive(Clone)]
+pub struct mailimf_mailbox_list(pub Vec<*mut mailimf_mailbox>);
 
-  - list is a list of mailboxes
+impl Drop for mailimf_mailbox_list {
-*/
+    fn drop(&mut self) {
-#[derive(Copy, Clone)]
+        for mb in &self.0 {
-#[repr(C)]
+            unsafe { mailimf_mailbox_free(*mb) };
-pub struct mailimf_mailbox_list {
+        }
-    pub mb_list: *mut clist,
+    }
 }
+
 /*
   mailimf_mailbox is a mailbox
 
@@ -507,18 +509,15 @@ pub unsafe fn mailimf_display_name_free(mut display_name: *mut libc::c_char) {
 pub unsafe fn mailimf_phrase_free(mut phrase: *mut libc::c_char) {
     free(phrase as *mut libc::c_void);
 }
-#[no_mangle]
+
-pub unsafe fn mailimf_mailbox_list_free(mut mb_list: *mut mailimf_mailbox_list) {
+pub unsafe fn mailimf_mailbox_list_free(mb_list: *mut mailimf_mailbox_list) {
-    clist_foreach(
+    if mb_list.is_null() {
-        (*mb_list).mb_list,
+        return;
-        ::std::mem::transmute::<Option<unsafe fn(_: *mut mailimf_mailbox) -> ()>, clist_func>(
+    }
-            Some(mailimf_mailbox_free),
+
-        ),
+    let _ = Box::from_raw(mb_list);
-        0 as *mut libc::c_void,
-    );
-    clist_free((*mb_list).mb_list);
-    free(mb_list as *mut libc::c_void);
 }
+
 #[no_mangle]
 pub unsafe fn mailimf_mailbox_free(mut mailbox: *mut mailimf_mailbox) {
     if !(*mailbox).mb_display_name.is_null() {
@@ -558,16 +557,18 @@ pub fn mailimf_group_new(
     Box::into_raw(Box::new(group))
 }
 
-#[no_mangle]
+pub fn mailimf_mailbox_list_new(mb_list: *mut clist) -> *mut mailimf_mailbox_list {
-pub unsafe fn mailimf_mailbox_list_new(mut mb_list: *mut clist) -> *mut mailimf_mailbox_list {
+    // convert clist into vec
-    let mut mbl: *mut mailimf_mailbox_list = 0 as *mut mailimf_mailbox_list;
+    let list: Vec<_> = unsafe { (*mb_list).into_iter() }
-    mbl = malloc(::std::mem::size_of::<mailimf_mailbox_list>() as libc::size_t)
+        .map(|mb| mb as *mut mailimf_mailbox)
-        as *mut mailimf_mailbox_list;
+        .collect();
-    if mbl.is_null() {
+
-        return 0 as *mut mailimf_mailbox_list;
+    // free clist
-    }
+    unsafe { clist_free(mb_list) }
-    (*mbl).mb_list = mb_list;
+
-    return mbl;
+    let mbl = mailimf_mailbox_list(list);
+
+    Box::into_raw(Box::new(mbl))
 }
 
 pub unsafe fn mailimf_address_list_new(mut ad_list: *mut clist) -> *mut mailimf_address_list {

mmime/src/mailimf/write_generic.rs

@@ -1050,14 +1050,8 @@ pub unsafe fn mailimf_mailbox_list_write_driver(
     let mut r: libc::c_int = 0;
     let mut first: libc::c_int = 0;
     first = 1i32;
-    cur = (*(*mb_list).mb_list).first;
+
-    while !cur.is_null() {
+    for mb in &(*mb_list).0 {
-        let mut mb: *mut mailimf_mailbox = 0 as *mut mailimf_mailbox;
-        mb = (if !cur.is_null() {
-            (*cur).data
-        } else {
-            0 as *mut libc::c_void
-        }) as *mut mailimf_mailbox;
         if 0 == first {
             r = mailimf_string_write_driver(
                 do_write,
@@ -1072,18 +1066,14 @@ pub unsafe fn mailimf_mailbox_list_write_driver(
         } else {
             first = 0i32
         }
-        r = mailimf_mailbox_write_driver(do_write, data, col, mb);
+        r = mailimf_mailbox_write_driver(do_write, data, col, *mb);
         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
 }
+
 unsafe fn mailimf_mailbox_write_driver(
     mut do_write: Option<
         unsafe fn(_: *mut libc::c_void, _: *const libc::c_char, _: size_t) -> libc::c_int,

mmime/src/other.rs

@@ -312,19 +312,10 @@ pub unsafe fn mailimf_mailbox_list_new_empty() -> *mut mailimf_mailbox_list {
   other code will be returned otherwise
 */
 pub unsafe fn mailimf_mailbox_list_add(
-    mut mailbox_list: *mut mailimf_mailbox_list,
+    mailbox_list: *mut mailimf_mailbox_list,
-    mut mb: *mut mailimf_mailbox,
+    mb: *mut mailimf_mailbox,
-) -> libc::c_int {
+) {
-    let mut r: libc::c_int = 0;
+    (*mailbox_list).0.push(mb);
-    r = clist_insert_after(
-        (*mailbox_list).mb_list,
-        (*(*mailbox_list).mb_list).last,
-        mb as *mut libc::c_void,
-    );
-    if r < 0i32 {
-        return MAILIMF_ERROR_MEMORY as libc::c_int;
-    }
-    return MAILIMF_NO_ERROR as libc::c_int;
 }
 
 /*

src/dc_mimeparser.rs

@@ -839,14 +839,12 @@ impl<'a> MimeParser<'a> {
                 fld_from.is_null()
             }
             || (*fld_from).frm_mb_list.is_null()
-            || (*(*fld_from).frm_mb_list).mb_list.is_null()
+            || (*(*(*fld_from).frm_mb_list).0).len() != 1)
-            || (*(*(*fld_from).frm_mb_list).mb_list).count != 1i32)
         {
-            let mb = (if !(*(*(*fld_from).frm_mb_list).mb_list).first.is_null() {
+            let mb = (*(*(*fld_from).frm_mb_list).0)
-                (*(*(*(*fld_from).frm_mb_list).mb_list).first).data
+                .first()
-            } else {
+                .map(|v| *v)
-                ptr::null_mut()
+                .unwrap_or_else(|| ptr::null_mut());
-            }) as *mut mailimf_mailbox;
 
             if !mb.is_null() {
                 let from_addr_norm = addr_normalize(as_str((*mb).mb_addr_spec));
@@ -916,8 +914,8 @@ pub fn mailimf_find_first_addr(mb_list: *const mailimf_mailbox_list) -> Option<S
         return None;
     }
 
-    for cur in unsafe { (*(*mb_list).mb_list).into_iter() } {
+    for mb in unsafe { &(*mb_list).0 } {
-        let mb = cur as *mut mailimf_mailbox;
+        let mb = *mb;
         if !mb.is_null() && !unsafe { (*mb).mb_addr_spec.is_null() } {
             let addr = unsafe { as_str((*mb).mb_addr_spec) };
             return Some(addr_normalize(addr).to_string());
@@ -1259,11 +1257,8 @@ pub fn mailimf_get_recipients(imffields: *mut mailimf_fields) -> HashSet<String>
                     }
                     mailimf_address::Group(group) => {
                         if !group.is_null() && unsafe { !(*group).mb_list.is_null() } {
-                            for cur3 in unsafe { &(*(*(*group).mb_list).mb_list) } {
+                            for mb in unsafe { &((*(*group).mb_list).0) } {
-                                mailimf_get_recipients_add_addr(
+                                mailimf_get_recipients_add_addr(&mut recipients, *mb);
-                                    &mut recipients,
-                                    cur3 as *mut mailimf_mailbox,
-                                );
                             }
                         }
                     }

src/dc_receive_imf.rs

@@ -1901,13 +1901,8 @@ unsafe fn dc_add_or_lookup_contacts_by_mailbox_list(
     if mb_list.is_null() {
         return;
     }
-    let mut cur: *mut clistiter = (*(*mb_list).mb_list).first;
+    for mb in &(*mb_list).0 {
-    while !cur.is_null() {
+        let mb = *mb;
-        let mb: *mut mailimf_mailbox = (if !cur.is_null() {
-            (*cur).data
-        } else {
-            ptr::null_mut()
-        }) as *mut mailimf_mailbox;
         if !mb.is_null() {
             add_or_lookup_contact_by_addr(
                 context,
@@ -1918,11 +1913,6 @@ unsafe fn dc_add_or_lookup_contacts_by_mailbox_list(
                 check_self,
             );
         }
-        cur = if !cur.is_null() {
-            (*cur).next
-        } else {
-            ptr::null_mut()
-        }
     }
 }