eml-codec 0.4.0

Email enCOder DECoder in Rust. Support Internet Message Format and MIME (RFC 822, 5322, 2045, 2046, 2047, 2048, 2049, 6532).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use bounded_static::ToStatic;
#[cfg(feature = "tracing")]
use tracing::warn;

#[cfg(feature = "arbitrary")]
use crate::fuzz_eq::FuzzEq;
use crate::header;
use crate::mime;
use crate::print::{Formatter, Print};
use crate::raw_input::RawInput;

/// Header field of a generic MIME entity (a MIME entity that is not a toplevel
/// message). Is either a MIME-defined field or an unstructured field.
#[derive(Clone, Debug, PartialEq, ToStatic)]
#[cfg_attr(feature = "arbitrary", derive(FuzzEq))]
pub enum EntityField<'a> {
    MIME {
        f: mime::field::Field<'a>,
        raw_body: RawInput<'a>,
    },
    Unstructured(header::Unstructured<'a>),
}

impl<'a> EntityField<'a> {
    pub fn raw_name(&self) -> header::FieldName<'a> {
        match self {
            EntityField::MIME { f, .. } => f.raw_name(),
            EntityField::Unstructured(u) => u.name.clone(),
        }
    }

    pub fn raw_body(&self) -> RawInput<'a> {
        match self {
            EntityField::MIME { raw_body, .. } => raw_body.clone(),
            EntityField::Unstructured(u) => u.raw_body.clone(),
        }
    }
}

impl<'a> Print for EntityField<'a> {
    fn print(&self, fmt: &mut impl Formatter) {
        match self {
            EntityField::MIME { f, .. } => f.print(fmt),
            EntityField::Unstructured(u) => u.print(fmt),
        }
    }
}

/// Entry for an entity field.
#[derive(Clone, Debug, PartialEq, ToStatic)]
#[cfg_attr(feature = "arbitrary", derive(FuzzEq))]
pub enum EntityEntry<'a> {
    MIME {
        e: mime::field::Entry,
        raw_body: RawInput<'a>,
    },
    Unstructured(header::Unstructured<'a>),
}

/// Collects fields and entries for a generic MIME entity. Only for eml-codec's
/// internal use.
#[derive(Debug, Default, PartialEq, ToStatic)]
#[cfg_attr(feature = "arbitrary", derive(FuzzEq))]
pub(crate) struct NaiveEntityFields<'a> {
    pub mime: mime::NaiveMIME<'a>,
    pub entries: Vec<EntityEntry<'a>>,
}

impl<'a> FromIterator<header::FieldRaw<'a>> for NaiveEntityFields<'a> {
    #[cfg_attr(
        feature = "tracing",
        tracing::instrument(name = "EntityFields::from_iter", skip(it))
    )]
    fn from_iter<I: IntoIterator<Item = header::FieldRaw<'a>>>(it: I) -> Self {
        let mut e: NaiveEntityFields<'a> = Default::default();
        for f in it {
            match mime::field::NaiveField::try_from(&f) {
                Ok(mimef) => {
                    if let Some(entry) = e.mime.add_field(mimef) {
                        e.entries.push(EntityEntry::MIME {
                            e: entry,
                            raw_body: f.body.into(),
                        })
                    } else {
                        // otherwise drop the field
                        #[cfg(feature = "tracing-recover")]
                        warn!(field = ?f, "dropping conflicting MIME field");
                    }
                    continue;
                }
                Err(mime::field::InvalidField::Body) => {
                    // this is a MIME field but its body is invalid; drop it.
                    #[cfg(feature = "tracing-unsupported")]
                    warn!(field = ?f, "dropping MIME field with an invalid body");
                    continue;
                }
                Err(mime::field::InvalidField::Name) => {
                    // not a MIME field
                }
            };

            if let Some(u) = header::Unstructured::from_raw(&f) {
                e.entries.push(EntityEntry::Unstructured(u));
            } else {
                // otherwise drop the field
                #[cfg(feature = "tracing-unsupported")]
                warn!(field = ?f, "dropping field which cannot be parsed as unstructured");
            }
        }
        e
    }
}