chatmail-core/mmime/src/display.rs

use crate::clist::*;

use crate::mailimf::types::*;
use crate::mailmime::types::*;

use std::ffi::CStr;

pub unsafe fn display_mime(mut mime: *mut Mailmime) {
    let mut cur: *mut clistiter = 0 as *mut clistiter;
    println!("{}", (*mime).mm_type);

    match (*mime).mm_type as u32 {
        MAILMIME_SINGLE => {
            println!("single part");
        }
        MAILMIME_MULTIPLE => {
            println!("multipart");
        }
        MAILMIME_MESSAGE => println!("message"),
        _ => {}
    }
    if !(*mime).mm_mime_fields.is_null() {
        if !(*(*(*mime).mm_mime_fields).fld_list).first.is_null() {
            print!("MIME headers begin");
            display_mime_fields((*mime).mm_mime_fields);
            println!("MIME headers end");
        }
    }
    display_mime_content((*mime).mm_content_type);
    match (*mime).mm_type as u32 {
        MAILMIME_SINGLE => {
            display_mime_data((*mime).mm_data.mm_single);
        }
        MAILMIME_MULTIPLE => {
            cur = (*(*mime).mm_data.mm_multipart.mm_mp_list).first;
            while !cur.is_null() {
                display_mime(
                    (if !cur.is_null() {
                        (*cur).data
                    } else {
                        0 as *mut libc::c_void
                    }) as *mut Mailmime,
                );
                cur = if !cur.is_null() {
                    (*cur).next
                } else {
                    0 as *mut clistcell
                }
            }
        }
        MAILMIME_MESSAGE => {
            if !(*mime).mm_data.mm_message.mm_fields.is_null() {
                if !(*(*mime).mm_data.mm_message.mm_fields).0.is_empty() {
                    println!("headers begin");
                    display_fields((*mime).mm_data.mm_message.mm_fields);
                    println!("headers end");
                }
                if !(*mime).mm_data.mm_message.mm_msg_mime.is_null() {
                    display_mime((*mime).mm_data.mm_message.mm_msg_mime);
                }
            }
        }
        _ => {}
    };
}

unsafe fn display_mime_content(mut content_type: *mut mailmime_content) {
    print!("type: ");
    display_mime_type((*content_type).ct_type);
    println!(
        "/{}",
        CStr::from_ptr((*content_type).ct_subtype).to_str().unwrap()
    );
}
unsafe fn display_mime_type(mut type_0: *mut mailmime_type) {
    match (*type_0).tp_type {
        1 => {
            display_mime_discrete_type((*type_0).tp_data.tp_discrete_type);
        }
        2 => {
            display_mime_composite_type((*type_0).tp_data.tp_composite_type);
        }
        _ => {}
    };
}
unsafe fn display_mime_composite_type(mut ct: *mut mailmime_composite_type) {
    match (*ct).ct_type {
        1 => {
            print!("message");
        }
        2 => {
            print!("multipart");
        }
        3 => {
            print!("{}", CStr::from_ptr((*ct).ct_token).to_str().unwrap());
        }
        _ => {}
    };
}
unsafe fn display_mime_discrete_type(mut discrete_type: *mut mailmime_discrete_type) {
    match (*discrete_type).dt_type {
        1 => {
            print!("text");
        }
        2 => {
            print!("image");
        }
        3 => {
            print!("audio");
        }
        4 => {
            print!("video");
        }
        5 => {
            print!("application");
        }
        6 => {
            print!("{}", (*discrete_type).dt_extension as u8 as char);
        }
        _ => {}
    };
}
unsafe fn display_mime_data(mut data: *mut mailmime_data) {
    match (*data).dt_type {
        0 => {
            println!(
                "data : {} bytes",
                (*data).dt_data.dt_text.dt_length as libc::c_uint,
            );
        }
        1 => {
            println!(
                "data (file) : {}",
                CStr::from_ptr((*data).dt_data.dt_filename)
                    .to_str()
                    .unwrap()
            );
        }
        _ => {}
    };
}
unsafe fn display_mime_dsp_parm(mut param: *mut mailmime_disposition_parm) {
    match (*param).pa_type {
        0 => {
            println!(
                "filename: {}",
                CStr::from_ptr((*param).pa_data.pa_filename)
                    .to_str()
                    .unwrap()
            );
        }
        _ => {}
    };
}
unsafe fn display_mime_disposition(mut disposition: *mut mailmime_disposition) {
    let mut cur: *mut clistiter = 0 as *mut clistiter;
    cur = (*(*disposition).dsp_parms).first;
    while !cur.is_null() {
        let mut param: *mut mailmime_disposition_parm = 0 as *mut mailmime_disposition_parm;
        param = (if !cur.is_null() {
            (*cur).data
        } else {
            0 as *mut libc::c_void
        }) as *mut mailmime_disposition_parm;
        display_mime_dsp_parm(param);
        cur = if !cur.is_null() {
            (*cur).next
        } else {
            0 as *mut clistcell
        }
    }
}
unsafe fn display_mime_field(mut field: *mut mailmime_field) {
    match (*field).fld_type {
        1 => {
            print!("content-type: ");
            display_mime_content((*field).fld_data.fld_content);
            println!("");
        }
        6 => {
            display_mime_disposition((*field).fld_data.fld_disposition);
        }
        _ => {}
    };
}
unsafe fn display_mime_fields(mut fields: *mut mailmime_fields) {
    let mut cur: *mut clistiter = 0 as *mut clistiter;
    cur = (*(*fields).fld_list).first;
    while !cur.is_null() {
        let mut 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 mailmime_field;
        display_mime_field(field);
        cur = if !cur.is_null() {
            (*cur).next
        } else {
            0 as *mut clistcell
        }
    }
}
unsafe fn display_date_time(mut d: *mut mailimf_date_time) {
    print!(
        "{:02}/{:02}/{:02} {:02}:{:02}:{:02} +{:04}",
        (*d).day,
        (*d).month,
        (*d).year,
        (*d).hour,
        (*d).min,
        (*d).sec,
        (*d).zone,
    );
}

unsafe fn display_orig_date(mut orig_date: *mut mailimf_orig_date) {
    display_date_time((*orig_date).dt_date_time);
}
unsafe fn display_mailbox(mut mb: *mut mailimf_mailbox) {
    if !(*mb).display_name.is_null() {
        print!("{}", CStr::from_ptr((*mb).display_name).to_str().unwrap());
    }
    print!("<{}>", CStr::from_ptr((*mb).addr_spec).to_str().unwrap());
}
unsafe fn display_mailbox_list(mut mb_list: *mut mailimf_mailbox_list) {
    for (i, mb) in (*mb_list).0.iter().enumerate() {
        display_mailbox(*mb);
        if i < (*mb_list).0.len() - 1 {
            print!(", ");
        }
    }
}

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()
    );
    for mb in &(*(*group).mb_list).0 {
        display_mailbox(*mb);
    }
    print!("; ");
}

unsafe fn display_address(a: *mut mailimf_address) {
    match *a {
        mailimf_address::Group(data) => {
            display_group(data);
        }
        mailimf_address::Mailbox(data) => {
            display_mailbox(data);
        }
    }
}

unsafe fn display_address_list(addr_list: *mut mailimf_address_list) {
    for (i, addr) in (*addr_list).0.iter().enumerate() {
        display_address(*addr);
        if i < (*addr_list).0.len() - 1 {
            print!(", ");
        }
    }
}

unsafe fn display_from(mut from: *mut mailimf_from) {
    display_mailbox_list((*from).frm_mb_list);
}
unsafe fn display_to(mut to: *mut mailimf_to) {
    display_address_list((*to).to_addr_list);
}
unsafe fn display_cc(mut cc: *mut mailimf_cc) {
    display_address_list((*cc).cc_addr_list);
}
unsafe fn display_subject(mut subject: *mut mailimf_subject) {
    print!("{}", CStr::from_ptr((*subject).sbj_value).to_str().unwrap());
}
unsafe fn display_field(field: &mailimf_field) {
    match *field {
        mailimf_field::OrigDate(date) => {
            print!("Date: ");
            display_orig_date(date);
            println!("");
        }
        mailimf_field::From(from) => {
            print!("From: ");
            display_from(from);
            println!("");
        }
        mailimf_field::To(to) => {
            print!("To: ");
            display_to(to);
            println!("");
        }
        mailimf_field::Cc(cc) => {
            print!("Cc: ");
            display_cc(cc);
            println!("");
        }
        mailimf_field::Subject(subject) => {
            print!("Subject: ");
            display_subject(subject);
            println!("");
        }
        mailimf_field::MessageId(message_id) => {
            println!(
                "Message-ID: {}",
                CStr::from_ptr((*message_id).mid_value).to_str().unwrap(),
            );
        }
        _ => {}
    };
}
unsafe fn display_fields(fields: *mut mailimf_fields) {
    for f in &(*fields).0 {
        display_field(f);
    }
}