br_email/

analyze.rs

use br_crypto::encoding::code_to_utf8;
use chrono::{DateTime, Local, TimeZone};
use json::{object, JsonValue};
use regex::Regex;
use std::collections::HashMap;
use std::ffi::OsStr;
use std::io::{Error, ErrorKind, Write};
use std::{env, fs, io};

/// 解析邮件
#[derive(Debug)]
pub struct AnalyzeEmails {
    pub debug: bool,
    pub header: HashMap<String, String>,
    pub mime_version: String,
    boundary: String,
    pub md5: String,
    pub size: usize,
    /// 时间戳
    pub timestamp: i64,
    /// 本地时间
    pub datetime: String,
    /// 主题
    pub subject: String,
    /// 发件人
    pub from: HashMap<String, String>,
    /// 收件人
    pub to: HashMap<String, String>,
    /// 抄送人
    pub cc: HashMap<String, String>,
    /// 用于指定收件人回复邮件时应该使用的电子邮件地址
    pub replyto: HashMap<String, String>,
    /// 内容类型
    pub content_type: String,
    /// 编码规则
    pub content_transfer_encoding: ContentTransferEncoding,
    /// 实际发件人
    pub sender: String,
    pub body_text: String,
    pub body_html: String,
    pub files: JsonValue,
    pub charset: String,
}

impl AnalyzeEmails {
    pub fn new(mut data: Vec<u8>, debug: bool) -> io::Result<AnalyzeEmails> {
        let md5 = br_crypto::md5::encrypt_hex(&data.clone())
            .leak()
            .to_string();
        let size = data.len();
        let data_string = unsafe { String::from_utf8_unchecked(data.clone()) };
        if data_string.contains("\n\n") {
            let updated_string = data_string.replace("\n", "\r\n");
            data = updated_string.as_bytes().to_vec();
        }

        let subsequence = "\r\n\r\n".as_bytes();

        let (header, body) = match data
            .windows(subsequence.len())
            .position(|window| window == subsequence)
        {
            None => {
                if debug {
                    fs::write(
                        format!(
                            "{}/xygs-{}.eml",
                            env::current_dir().unwrap().to_str().unwrap(),
                            md5
                        ),
                        data.clone(),
                    )?;
                }
                return Err(Error::other(format!("协议格式错误: {md5}")));
            }
            Some(e) => (data[..e].to_vec(), data[e + 4..].to_vec()),
        };
        let mut that = Self {
            debug,
            header: Default::default(),
            mime_version: "".to_string(),
            boundary: "".to_string(),
            md5,
            size,
            timestamp: 0,
            subject: "".to_string(),
            from: Default::default(),
            to: Default::default(),
            cc: Default::default(),
            replyto: Default::default(),
            datetime: "".to_string(),
            content_type: "".to_string(),
            content_transfer_encoding: ContentTransferEncoding::Bit7,
            sender: "".to_string(),
            body_text: "".to_string(),
            body_html: "".to_string(),
            files: object! {},
            charset: "utf-8".to_string(),
        };
        that.header(header)?;
        that.body(body, data_string)?;
        Ok(that)
    }

    fn header(&mut self, data: Vec<u8>) -> io::Result<()> {
        let data = unsafe { String::from_utf8_unchecked(data) };
        let data = data.replace("\r\n\t", "").replace("\r\n ", " ").leak();
        for item in data.lines() {
            let (key, value) = match item.find(": ") {
                Some(e) => (&item[..e], &item[e + 2..]),
                None => match item.find(":") {
                    Some(e) => (&item[..e], &item[e + 1..]),
                    None => continue,
                },
            };
            let name = key.to_lowercase().leak();
            if value.is_empty() {
                continue;
            }
            match key.to_lowercase().as_str() {
                "mime-version" => self.mime_version = value.to_string(),
                "from" => {
                    self.from = self.from(value);
                }
                "sender" => {
                    self.sender = value.to_string();
                }
                "to" => {
                    self.to = self.email_encoded(value);
                }
                "cc" => {
                    self.cc = self.email_encoded(value);
                }
                "reply-to" => {
                    self.replyto = self.email_encoded(value);
                }
                "subject" => {
                    self.subject = self.subject(value.to_string());
                }
                "content-type" => {
                    let types = value.split(";").collect::<Vec<&str>>();
                    self.content_type = types[0].trim().to_lowercase().to_string();
                    match self.content_type.as_str() {
                        "multipart/mixed"
                        | "multipart/alternative"
                        | "multipart/related"
                        | "multipart/report" => match types[1].find("boundary=") {
                            None => {}
                            Some(e) => {
                                let boundary = &types[1][e..];
                                self.boundary = boundary
                                    .trim()
                                    .trim_start_matches("boundary=")
                                    .trim_start_matches("\"")
                                    .trim_end_matches("\"")
                                    .to_string();
                            }
                        },
                        _ => {}
                    }
                    if types.len() > 1 {
                        for item in types.iter() {
                            if item.contains("charset=") {
                                self.charset = item
                                    .trim_start_matches("charset=")
                                    .trim_start_matches("\"")
                                    .trim_end_matches("\"")
                                    .to_string();
                            }
                        }
                    }
                }
                "content-transfer-encoding" => {
                    self.content_transfer_encoding = ContentTransferEncoding::from(value);
                }
                "date" => self.datetime(value)?,
                _ => {
                    self.header
                        .insert(name.trim().to_string(), value.to_string());
                }
            }
        }
        Ok(())
    }
    fn body(&mut self, data: Vec<u8>, old_data: String) -> io::Result<()> {
        match self.content_type.to_lowercase().as_str() {
            "text/html" => {
                let data = self.content_transfer_encoding.decode(data)?;
                let res = code_to_utf8(self.charset.as_str(), data.clone());
                self.body_html = res;
            }
            "text/plain" => {
                let data = self.content_transfer_encoding.decode(data)?;
                let res = code_to_utf8(self.charset.as_str(), data.clone());
                self.body_text = res;
            }
            "multipart/mixed"
            | "multipart/alternative"
            | "multipart/related"
            | "multipart/report" => {
                let data = self.content_transfer_encoding.decode(data.clone())?;
                let mut parts = code_to_utf8(self.charset.as_str(), data.clone());
                let mut parts_list = vec![];
                let mut text = String::new();

                parts = match parts.find(self.boundary.as_str()) {
                    None => parts,
                    Some(e) => parts[e..].to_string(),
                };
                for item in parts.lines() {
                    if item.contains(self.boundary.as_str()) && text.is_empty() {
                        continue;
                    }
                    if item.contains(self.boundary.as_str()) && text.clone() != "" {
                        parts_list.push(text.clone());
                        text = String::new();
                        continue;
                    }
                    text = format!("{text}{item}\r\n");
                }
                for part in parts_list {
                    if part.trim().is_empty() {
                        continue;
                    }
                    self.parts(part.to_string(), old_data.clone())?;
                }
            }
            _ => {
                return Err(Error::new(
                    ErrorKind::NotFound,
                    format!("未知body类型: {}", self.content_type),
                ));
            }
        }
        Ok(())
    }
    /// 部分内容处理
    fn parts(&mut self, data: String, old_data: String) -> io::Result<()> {
        let (header, body) = match data.find("\r\n\r\n") {
            None => {
                if self.debug {
                    fs::write(
                        format!(
                            "{}/head-{}.eml",
                            env::current_dir().unwrap().to_str().unwrap(),
                            self.md5
                        ),
                        old_data.clone(),
                    )?;
                }
                return Err(Error::other("解析附件头失败"));
            }
            Some(e) => (
                &data[..e]
                    .replace("\r\n\t", " ")
                    .replace("\r\n ", " ")
                    .leak()
                    .lines(),
                &data[e + 4..],
            ),
        };

        let mut filename = "".to_string();
        let mut content_type = "";
        let mut boundary = "";
        let mut content_transfer_encoding = ContentTransferEncoding::None;
        for item in header.clone() {
            let (key, value) = match item.find(": ") {
                Some(e) => (&item[..e], &item[e + 2..]),
                None => match item.find(":") {
                    Some(e) => (&item[..e], &item[e + 1..]),
                    None => continue,
                },
            };

            let name = key.to_lowercase();

            match name.trim() {
                "content-transfer-encoding" => {
                    content_transfer_encoding = ContentTransferEncoding::from(value)
                }
                "content-type" => {
                    let types = value.trim().split(";").collect::<Vec<&str>>();
                    content_type = types[0].trim();
                    let name = types
                        .iter()
                        .filter(|&x| x.trim().starts_with("name="))
                        .map(|&x| x.trim().to_string())
                        .collect::<Vec<String>>();
                    if !name.is_empty() {
                        let name = name[0].trim_start_matches("name=");
                        filename = self.encoded(name);
                    }
                    match value.find("boundary=") {
                        None => {}
                        Some(i) => {
                            boundary = &value[i + 9..];
                            boundary = match boundary.find(";") {
                                None => boundary,
                                Some(i) => &boundary[..i],
                            };
                            boundary = boundary.trim_start_matches("\"").trim_end_matches("\"");
                        }
                    }
                }
                "content-id"
                | "content-length"
                | "mime-version"
                | "content-description"
                | "date"
                | "x-attachment-id" => {}
                "content-disposition" => {
                    if filename.is_empty() && value.contains("filename=") {
                        filename = value.split("filename=").collect::<Vec<&str>>()[1]
                            .trim_start_matches("\"")
                            .trim_end_matches("\"")
                            .to_string();
                    }
                    if filename.is_empty() && value.contains("filename*=utf-8''") {
                        filename = value.split("filename*=utf-8''").collect::<Vec<&str>>()[1]
                            .trim_start_matches("\"")
                            .trim_end_matches("\"")
                            .to_string();
                        filename = br_crypto::encoding::urlencoding_decode(filename.as_str());
                    }
                }
                _ => {
                    return Err(Error::new(
                        ErrorKind::NotFound,
                        format!("parts 未知 header 类型: {name} [{item}]"),
                    ));
                }
            }
        }

        match content_type {
            "text/plain" => {
                if filename.is_empty() {
                    let res = content_transfer_encoding.decode(body.as_bytes().to_vec())?;
                    let text = code_to_utf8(self.charset.as_str(), res.clone());
                    self.body_text = text;
                } else {
                    self.set_files(
                        content_transfer_encoding,
                        body,
                        filename.as_str(),
                        "".to_string(),
                    )?;
                }
            }
            "text/html" | "text/x-amp-html" => {
                if filename.is_empty() {
                    let res = content_transfer_encoding.decode(body.as_bytes().to_vec())?;
                    self.body_html = code_to_utf8(self.charset.as_str(), res.clone());
                } else {
                    self.set_files(
                        content_transfer_encoding,
                        body,
                        filename.as_str(),
                        "".to_string(),
                    )?;
                }
            }
            "multipart/mixed" | "multipart/alternative" | "multipart/related" => {
                let data = self
                    .content_transfer_encoding
                    .decode(body.as_bytes().to_vec())?;
                let mut parts = code_to_utf8(self.charset.as_str(), data.clone());

                parts = match parts.find(self.boundary.as_str()) {
                    None => parts,
                    Some(e) => parts[e..].to_string(),
                };

                let mut parts_list = vec![];
                let mut text = String::new();
                for item in parts.lines() {
                    if item.contains(boundary) && text.is_empty() {
                        continue;
                    }
                    if item.contains(boundary) && !text.is_empty() {
                        parts_list.push(text);
                        text = String::new();
                        continue;
                    }
                    text = format!("{text}{item}\r\n");
                }
                for part in parts_list {
                    if part.trim().is_empty() {
                        continue;
                    }
                    self.parts(part.to_string(), old_data.clone())?;
                }
            }
            "text/calendar" => {}
            "application/octet-stream"
            | "application/zip"
            | "application/pdf"
            | "image/jpeg"
            | "application/ics"
            | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" => {
                if !filename.is_empty() {
                    self.set_files(
                        content_transfer_encoding,
                        body,
                        filename.as_str(),
                        content_type.to_string(),
                    )?;
                }
            }
            _ => {
                if self.debug {
                    fs::write(
                        format!(
                            "{}/content_type-{}.eml",
                            env::current_dir().unwrap().to_str().unwrap(),
                            self.md5
                        ),
                        old_data.clone(),
                    )?;
                }
                return Err(Error::new(
                    ErrorKind::NotFound,
                    format!("未知 parts content_type 类型: {content_type}"),
                ));
            }
        }
        Ok(())
    }
    pub fn from(&mut self, value: &str) -> HashMap<String, String> {
        let mut r = value
            .split("<")
            .filter(|x| !x.trim().is_empty())
            .map(|x| x.trim())
            .collect::<Vec<&str>>();
        if r[0].starts_with("\"") && r[0].ends_with("\"") {
            r[0] = r[0].trim_start_matches("\"").trim_end_matches("\"").trim();
        }
        let mut emails = HashMap::new();
        if r.len() == 1 {
            let name = r[0].trim_end_matches(">").to_string();
            emails.insert(name.clone(), name);
        } else {
            let name = self.encoded(r[0].trim());
            let email = r[1].trim_end_matches(">").to_string();
            emails.insert(email, name);
        }
        emails
    }
    fn subject(&mut self, value: String) -> String {
        let value = value.replace("?==?", "?=\r\n\t=?");
        if !value.contains("=?") && !value.contains("?=") {
            return value.to_string();
        }
        let list = value.split("\r\n\t").collect::<Vec<&str>>();
        let mut txt = vec![];
        for item in list {
            txt.push(self.encoded(item));
        }
        txt.join("")
    }

    fn encoded(&mut self, value: &str) -> String {
        let t = value.trim_start_matches("\"").trim_end_matches("\"");
        if t.contains("=?") && t.contains("?=") {
            let l = t.split(" ").collect::<Vec<&str>>();
            let mut txt = vec![];
            for item in l {
                txt.push(self.encoded_line(item));
            }
            txt.join("")
        } else {
            t.to_string()
        }
    }
    /// 段落解码
    fn encoded_line(&mut self, value: &str) -> String {
        let line = value.split("?").collect::<Vec<&str>>();
        if line.len() == 1 {
            return value.to_string();
        }
        let charset = line[1].to_lowercase().to_string().leak();
        let code = line[2].to_uppercase();
        let data = line[3];

        let strs = match code.as_str() {
            "B" => br_crypto::base64::decode_u8(data),
            "Q" => br_crypto::qp::decode(data).unwrap_or(vec![]),
            _ => data.as_bytes().to_vec(),
        };
        let text = code_to_utf8(charset, strs.clone());
        text.chars().filter(|&x| x != '\u{200b}').collect()
    }

    /// 时间处理
    fn datetime(&mut self, value: &str) -> io::Result<()> {
        let re = Regex::new(r"\s*\(.*\)$").unwrap();
        let datetime = re.replace(value, "").to_string();
        let datetime = datetime.replace("GMT", "+0000").to_string();
        let datetime = match datetime.find(",") {
            None => datetime,
            Some(i) => datetime[i + 1..].parse().unwrap(),
        };
        let datetime = match DateTime::parse_from_str(datetime.as_str(), "%d %b %Y %H:%M:%S %z") {
            Ok(e) => e,
            Err(e) => return Err(Error::other(format!("时间解析失败: {e} [{datetime:?}]"))),
        };
        self.timestamp = datetime.timestamp();
        self.datetime = Local
            .timestamp_opt(self.timestamp, 0)
            .unwrap()
            .with_timezone(&Local)
            .format("%Y-%m-%d %H:%M:%S")
            .to_string();
        Ok(())
    }
    pub fn email_encoded(&mut self, value: &str) -> HashMap<String, String> {
        let list = value.split(",").map(|x| x.trim()).collect::<Vec<&str>>();
        let mut emails = HashMap::new();
        for item in list {
            let mut r = item.split(" <").collect::<Vec<&str>>();
            if r[0].starts_with("\"") && r[0].ends_with("\"") {
                r[0] = r[0].trim_start_matches("\"").trim_end_matches("\"");
            }
            if r.len() == 1 {
                let name = r[0]
                    .trim_start_matches("<")
                    .trim_end_matches(">")
                    .to_string();
                emails.insert(name.clone(), name);
            } else {
                let name = self.encoded(r[0].trim());
                let email = r[1].trim_end_matches(">").to_string();
                emails.insert(email, name);
            }
        }
        emails
    }
    fn set_files(
        &mut self,
        mut content_transfer_encoding: ContentTransferEncoding,
        body: &str,
        filename: &str,
        mut content_type: String,
    ) -> io::Result<()> {
        let mut data = "";
        if let ContentTransferEncoding::Base64 = content_transfer_encoding {
            let mut text = "".to_string();
            for line in body.lines() {
                text += line;
            }
            data = text.leak();
        }

        let body = content_transfer_encoding.decode(data.as_bytes().to_vec())?;
        let md5 = br_crypto::md5::encrypt_hex(&body.clone());
        let size = body.len();
        let mut temp_dir = env::temp_dir();
        temp_dir.push(filename);
        let path_temp_dir = temp_dir.clone();

        let mut temp_file = match fs::File::create(temp_dir.clone()) {
            Ok(e) => e,
            Err(e) => {
                return Err(Error::other(format!(
                    "打开（创建）临时文件: {e} [{filename}]"
                )))
            }
        };

        if temp_file.write(body.as_slice()).is_ok() {
            if content_type.is_empty() {
                content_type = path_temp_dir
                    .extension()
                    .unwrap_or(OsStr::new("unknown"))
                    .to_str()
                    .unwrap_or("unknown")
                    .to_string();
            }

            self.files[md5.as_str()] = object! {
                name:filename,
                md5:md5.clone(),
                size:size,
                "content-type":content_type.clone(),
                file:temp_dir.to_str()
            };
        };
        Ok(())
    }
}

impl Default for AnalyzeEmails {
    fn default() -> Self {
        Self {
            debug: false,
            header: Default::default(),
            mime_version: "".to_string(),
            boundary: "".to_string(),
            md5: "".to_string(),
            size: 0,
            timestamp: 0,
            datetime: "".to_string(),
            subject: "".to_string(),
            from: Default::default(),
            to: Default::default(),
            cc: Default::default(),
            replyto: Default::default(),
            content_type: "".to_string(),
            content_transfer_encoding: ContentTransferEncoding::None,
            sender: "".to_string(),
            body_text: "".to_string(),
            body_html: "".to_string(),
            files: JsonValue::Null,
            charset: "".to_string(),
        }
    }
}

/// 编码规则
/// 选择 Content-Transfer-Encoding 的原则
///
/// 纯文本: 如果内容是纯文本且只包含 ASCII 字符，通常使用 7bit。
/// 非 ASCII 文本: 如果内容包含非 ASCII 字符，可以使用 quoted-printable 或 8bit，具体取决于内容和兼容性要求。
/// 二进制数据: 对于图像、视频、音频等二进制数据，通常使用 base64 编码。
#[derive(Debug)]
pub enum ContentTransferEncoding {
    /// 这种编码方式主要用于编码文本数据，它保持大部分文本的可读性，但会对非 ASCII 字符和特殊字符（如 =, ?, & 等）进行编码，以确保兼容性。
    /// 适用于包含大量特殊字符或非 ASCII 文本的邮件内容。
    QuotedPrintable,
    ///    将二进制数据编码为 ASCII 字符串，使用 64 个字符的字母表（A-Z, a-z, 0-9, +, /）表示二进制数据。每 3 个字节的二进制数据编码为 4 个字符，便于在邮件中传输。
    /// 常用于编码附件、图像、音频、视频等二进制数据。
    Base64,
    /// 表示内容是二进制数据，不能被转义或编码，必须保持原始的二进制格式进行传输。这种编码方式通常用于图像、音频等二进制文件。
    /// 这种编码要求邮件传输代理能够处理所有可能的字节值，几乎不做任何转换，因此也不是所有系统都支持。
    Binary,
    /// 表示内容包含 8 位字符，这意味着它可能包含非 ASCII 字符（如带有音标的字母）。尽管这样编码的邮件可以包含更多字符，但并非所有邮件传输代理都支持 8bit 传输。
    /// 适用于非 ASCII 的文本数据，但需要确保邮件传输链路支持 8bit 数据传输。
    Bit8,
    /// 表示内容是 ASCII 文本，仅包含 7 位字符（即标准 ASCII 字符集），每个字符的最高位是 0。这种编码方式是最常用的，因为它适合绝大多数邮件传输系统。
    /// 适用于纯文本邮件，不包含任何特殊字符或二进制数据。
    Bit7,
    None,
}

impl ContentTransferEncoding {
    fn from(value: &str) -> Self {
        match value.to_lowercase().as_str() {
            "7bit" => Self::Bit7,
            "8bit" => Self::Bit8,
            "binary" => Self::Binary,
            "base64" => Self::Base64,
            "quoted-printable" => Self::QuotedPrintable,
            _ => Self::None,
        }
    }
    fn decode(&mut self, mut data: Vec<u8>) -> io::Result<Vec<u8>> {
        let res = match self {
            ContentTransferEncoding::QuotedPrintable => br_crypto::qp::decode(data)?,
            ContentTransferEncoding::Base64 => {
                let str = unsafe { String::from_utf8_unchecked(data) };
                let mut text = "".to_string();
                for line in str.lines() {
                    text += line;
                }
                data = text.leak().as_bytes().to_vec();
                br_crypto::base64::decode_u8(data)
            }
            ContentTransferEncoding::Binary => data,
            ContentTransferEncoding::Bit8 => data,
            ContentTransferEncoding::Bit7 => data,
            ContentTransferEncoding::None => data,
        };
        Ok(res)
    }
}