Merge pull request 'Access headers as key/values' (#24) from headers_map into main
Reviewed-on: #24
This commit is contained in:
commit
5ccc212d15
12 changed files with 423 additions and 339 deletions
102
src/header.rs
102
src/header.rs
|
@ -1,55 +1,62 @@
|
|||
|
||||
use crate::text::misc_token::{unstructured, Unstructured};
|
||||
use crate::text::whitespace::{foldable_line, obs_crlf};
|
||||
use nom::{
|
||||
branch::alt,
|
||||
bytes::complete::{tag, tag_no_case, take_while1},
|
||||
bytes::complete::{tag, take_while1},
|
||||
character::complete::space0,
|
||||
combinator::map,
|
||||
multi::{fold_many0},
|
||||
combinator::{into, recognize},
|
||||
multi::many0,
|
||||
sequence::{pair, terminated, tuple},
|
||||
IResult,
|
||||
};
|
||||
use std::fmt;
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub enum CompField<'a, T> {
|
||||
Known(T),
|
||||
Unknown(Kv<'a>),
|
||||
Bad(&'a [u8]),
|
||||
use crate::text::misc_token::unstructured;
|
||||
use crate::text::whitespace::{foldable_line, obs_crlf};
|
||||
|
||||
#[derive(PartialEq, Clone)]
|
||||
pub struct Kv2<'a>(pub &'a [u8], pub &'a [u8]);
|
||||
impl<'a> From<(&'a [u8], &'a [u8])> for Kv2<'a> {
|
||||
fn from(pair: (&'a [u8], &'a [u8])) -> Self {
|
||||
Self(pair.0, pair.1)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Clone)]
|
||||
pub struct Kv<'a>(pub &'a [u8], pub Unstructured<'a>);
|
||||
|
||||
|
||||
pub fn header<'a, T>(
|
||||
fx: impl Fn(&'a [u8]) -> IResult<&'a [u8], T> + Copy,
|
||||
) -> impl Fn(&'a [u8]) -> IResult<&'a [u8], (Vec::<T>, Vec::<Kv>, Vec<&'a [u8]>)> {
|
||||
move |input| {
|
||||
terminated(
|
||||
fold_many0(
|
||||
alt((
|
||||
map(fx, CompField::Known),
|
||||
map(opt_field, |(k, v)| CompField::Unknown(Kv(k, v))),
|
||||
map(foldable_line, CompField::Bad),
|
||||
)),
|
||||
|| (Vec::<T>::new(), Vec::<Kv>::new(), Vec::<&'a [u8]>::new()),
|
||||
|(mut known, mut unknown, mut bad), item| {
|
||||
match item {
|
||||
CompField::Known(v) => known.push(v),
|
||||
CompField::Unknown(v) => unknown.push(v),
|
||||
CompField::Bad(v) => bad.push(v),
|
||||
};
|
||||
(known, unknown, bad)
|
||||
}
|
||||
),
|
||||
obs_crlf,
|
||||
)(input)
|
||||
impl<'a> fmt::Debug for Kv2<'a> {
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
fmt.debug_tuple("header::Kv2")
|
||||
.field(&String::from_utf8_lossy(self.0))
|
||||
.field(&String::from_utf8_lossy(self.1))
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn field_name<'a>(name: &'static [u8]) -> impl Fn(&'a [u8]) -> IResult<&'a [u8], &'a [u8]> {
|
||||
move |input| terminated(tag_no_case(name), tuple((space0, tag(b":"), space0)))(input)
|
||||
#[derive(Debug, PartialEq, Clone)]
|
||||
pub enum Field<'a> {
|
||||
Good(Kv2<'a>),
|
||||
Bad(&'a [u8]),
|
||||
}
|
||||
impl<'a> From<Kv2<'a>> for Field<'a> {
|
||||
fn from(kv: Kv2<'a>) -> Self {
|
||||
Self::Good(kv)
|
||||
}
|
||||
}
|
||||
impl<'a> From<&'a [u8]> for Field<'a> {
|
||||
fn from(bad: &'a [u8]) -> Self {
|
||||
Self::Bad(bad)
|
||||
}
|
||||
}
|
||||
|
||||
/// Parse headers as key/values
|
||||
pub fn header_kv(input: &[u8]) -> IResult<&[u8], Vec<Field>> {
|
||||
terminated(
|
||||
many0(alt((into(correct_field), into(foldable_line)))),
|
||||
obs_crlf,
|
||||
)(input)
|
||||
}
|
||||
|
||||
pub fn field_any(input: &[u8]) -> IResult<&[u8], &[u8]> {
|
||||
terminated(
|
||||
take_while1(|c| (0x21..=0x7E).contains(&c) && c != 0x3A),
|
||||
tuple((space0, tag(b":"), space0)),
|
||||
)(input)
|
||||
}
|
||||
|
||||
/// Optional field
|
||||
|
@ -61,15 +68,6 @@ pub fn field_name<'a>(name: &'static [u8]) -> impl Fn(&'a [u8]) -> IResult<&'a [
|
|||
/// %d59-126 ; characters not including
|
||||
/// ; ":".
|
||||
/// ```
|
||||
pub fn opt_field(input: &[u8]) -> IResult<&[u8], (&[u8], Unstructured)> {
|
||||
terminated(
|
||||
pair(
|
||||
terminated(
|
||||
take_while1(|c| (0x21..=0x7E).contains(&c) && c != 0x3A),
|
||||
tuple((space0, tag(b":"), space0)),
|
||||
),
|
||||
unstructured,
|
||||
),
|
||||
obs_crlf,
|
||||
)(input)
|
||||
pub fn correct_field(input: &[u8]) -> IResult<&[u8], Kv2> {
|
||||
terminated(into(pair(field_any, recognize(unstructured))), obs_crlf)(input)
|
||||
}
|
||||
|
|
127
src/imf/field.rs
127
src/imf/field.rs
|
@ -1,21 +1,14 @@
|
|||
use chrono::{DateTime, FixedOffset};
|
||||
use nom::{
|
||||
branch::alt,
|
||||
combinator::map,
|
||||
sequence::{preceded, terminated},
|
||||
IResult,
|
||||
};
|
||||
use nom::combinator::map;
|
||||
|
||||
use crate::header::{field_name, header};
|
||||
use crate::header;
|
||||
use crate::imf::address::{address_list, mailbox_list, nullable_address_list, AddressList};
|
||||
use crate::imf::datetime::section as date;
|
||||
use crate::imf::identification::{msg_id, msg_list, MessageID, MessageIDList};
|
||||
use crate::imf::mailbox::{mailbox, AddrSpec, MailboxList, MailboxRef};
|
||||
use crate::imf::mime::{version, Version};
|
||||
use crate::imf::trace::{received_log, return_path, ReceivedLog};
|
||||
use crate::imf::Imf;
|
||||
use crate::text::misc_token::{phrase_list, unstructured, PhraseList, Unstructured};
|
||||
use crate::text::whitespace::obs_crlf;
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub enum Field<'a> {
|
||||
|
@ -49,94 +42,34 @@ pub enum Field<'a> {
|
|||
|
||||
MIMEVersion(Version),
|
||||
}
|
||||
|
||||
pub fn field(input: &[u8]) -> IResult<&[u8], Field> {
|
||||
terminated(
|
||||
alt((
|
||||
preceded(field_name(b"date"), map(date, Field::Date)),
|
||||
preceded(field_name(b"from"), map(mailbox_list, Field::From)),
|
||||
preceded(field_name(b"sender"), map(mailbox, Field::Sender)),
|
||||
preceded(field_name(b"reply-to"), map(address_list, Field::ReplyTo)),
|
||||
preceded(field_name(b"to"), map(address_list, Field::To)),
|
||||
preceded(field_name(b"cc"), map(address_list, Field::Cc)),
|
||||
preceded(field_name(b"bcc"), map(nullable_address_list, Field::Bcc)),
|
||||
preceded(field_name(b"message-id"), map(msg_id, Field::MessageID)),
|
||||
preceded(field_name(b"in-reply-to"), map(msg_list, Field::InReplyTo)),
|
||||
preceded(field_name(b"references"), map(msg_list, Field::References)),
|
||||
preceded(field_name(b"subject"), map(unstructured, Field::Subject)),
|
||||
preceded(field_name(b"comments"), map(unstructured, Field::Comments)),
|
||||
preceded(field_name(b"keywords"), map(phrase_list, Field::Keywords)),
|
||||
preceded(
|
||||
field_name(b"return-path"),
|
||||
map(return_path, Field::ReturnPath),
|
||||
),
|
||||
preceded(field_name(b"received"), map(received_log, Field::Received)),
|
||||
preceded(
|
||||
field_name(b"mime-version"),
|
||||
map(version, Field::MIMEVersion),
|
||||
),
|
||||
)),
|
||||
obs_crlf,
|
||||
)(input)
|
||||
}
|
||||
|
||||
pub fn imf(input: &[u8]) -> IResult<&[u8], Imf> {
|
||||
map(header(field), |(known, unknown, bad)| {
|
||||
let mut imf = Imf::from_iter(known);
|
||||
imf.header_ext = unknown;
|
||||
imf.header_bad = bad;
|
||||
imf
|
||||
})(input)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::imf::address::*;
|
||||
use crate::imf::mailbox::*;
|
||||
use crate::text::misc_token::*;
|
||||
use chrono::{FixedOffset, TimeZone};
|
||||
|
||||
#[test]
|
||||
fn test_header() {
|
||||
let fullmail = b"Date: 7 Mar 2023 08:00:00 +0200
|
||||
From: someone@example.com
|
||||
To: someone_else@example.com
|
||||
Subject: An RFC 822 formatted message
|
||||
|
||||
This is the plain text body of the message. Note the blank line
|
||||
between the header information and the body of the message.";
|
||||
|
||||
assert_eq!(
|
||||
imf(fullmail),
|
||||
Ok((
|
||||
&b"This is the plain text body of the message. Note the blank line\nbetween the header information and the body of the message."[..],
|
||||
Imf {
|
||||
date: Some(FixedOffset::east_opt(2 * 3600).unwrap().with_ymd_and_hms(2023, 3, 7, 8, 0, 0).unwrap()),
|
||||
from: vec![MailboxRef {
|
||||
name: None,
|
||||
addrspec: AddrSpec {
|
||||
local_part: LocalPart(vec![LocalPartToken::Word(Word::Atom(&b"someone"[..]))]),
|
||||
domain: Domain::Atoms(vec![&b"example"[..], &b"com"[..]]),
|
||||
}
|
||||
}],
|
||||
to: vec![AddressRef::Single(MailboxRef {
|
||||
name: None,
|
||||
addrspec: AddrSpec {
|
||||
local_part: LocalPart(vec![LocalPartToken::Word(Word::Atom(&b"someone_else"[..]))]),
|
||||
domain: Domain::Atoms(vec![&b"example"[..], &b"com"[..]]),
|
||||
}
|
||||
})],
|
||||
subject: Some(Unstructured(vec![
|
||||
UnstrToken::Plain(&b"An"[..]),
|
||||
UnstrToken::Plain(&b"RFC"[..]),
|
||||
UnstrToken::Plain(&b"822"[..]),
|
||||
UnstrToken::Plain(&b"formatted"[..]),
|
||||
UnstrToken::Plain(&b"message"[..]),
|
||||
])),
|
||||
..Imf::default()
|
||||
impl<'a> TryFrom<&header::Field<'a>> for Field<'a> {
|
||||
type Error = ();
|
||||
fn try_from(f: &header::Field<'a>) -> Result<Self, Self::Error> {
|
||||
let content = match f {
|
||||
header::Field::Good(header::Kv2(key, value)) => {
|
||||
match key.to_ascii_lowercase().as_slice() {
|
||||
b"date" => map(date, Field::Date)(value),
|
||||
b"from" => map(mailbox_list, Field::From)(value),
|
||||
b"sender" => map(mailbox, Field::Sender)(value),
|
||||
b"reply-to" => map(address_list, Field::ReplyTo)(value),
|
||||
b"to" => map(address_list, Field::To)(value),
|
||||
b"cc" => map(address_list, Field::Cc)(value),
|
||||
b"bcc" => map(nullable_address_list, Field::Bcc)(value),
|
||||
b"message-id" => map(msg_id, Field::MessageID)(value),
|
||||
b"in-reply-to" => map(msg_list, Field::InReplyTo)(value),
|
||||
b"references" => map(msg_list, Field::References)(value),
|
||||
b"subject" => map(unstructured, Field::Subject)(value),
|
||||
b"comments" => map(unstructured, Field::Comments)(value),
|
||||
b"keywords" => map(phrase_list, Field::Keywords)(value),
|
||||
b"return-path" => map(return_path, Field::ReturnPath)(value),
|
||||
b"received" => map(received_log, Field::Received)(value),
|
||||
b"mime-version" => map(version, Field::MIMEVersion)(value),
|
||||
_ => return Err(()),
|
||||
}
|
||||
)),
|
||||
)
|
||||
}
|
||||
_ => return Err(()),
|
||||
};
|
||||
|
||||
content.map(|(_, content)| content).or(Err(()))
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,5 +1,4 @@
|
|||
/// Parse and represent IMF (Internet Message Format) headers (RFC822, RFC5322)
|
||||
|
||||
pub mod address;
|
||||
pub mod datetime;
|
||||
pub mod field;
|
||||
|
@ -8,13 +7,15 @@ pub mod mailbox;
|
|||
pub mod mime;
|
||||
pub mod trace;
|
||||
|
||||
use nom::{combinator::map, IResult};
|
||||
|
||||
use crate::header;
|
||||
use crate::imf::address::AddressRef;
|
||||
use crate::imf::field::Field;
|
||||
use crate::imf::identification::MessageID;
|
||||
use crate::imf::mailbox::{AddrSpec, MailboxRef};
|
||||
use crate::imf::mime::Version;
|
||||
use crate::imf::trace::ReceivedLog;
|
||||
use crate::header;
|
||||
use crate::text::misc_token::{PhraseList, Unstructured};
|
||||
use chrono::{DateTime, FixedOffset};
|
||||
|
||||
|
@ -51,17 +52,13 @@ pub struct Imf<'a> {
|
|||
// MIME
|
||||
pub mime_version: Option<Version>,
|
||||
|
||||
// Junk
|
||||
pub header_ext: Vec<header::Kv<'a>>,
|
||||
pub header_bad: Vec<&'a [u8]>,
|
||||
// Raw fields
|
||||
pub kv: Vec<header::Field<'a>>,
|
||||
}
|
||||
|
||||
impl<'a> Imf<'a> {
|
||||
pub fn with_opt(mut self, opt: Vec<header::Kv<'a>>) -> Self {
|
||||
self.header_ext = opt; self
|
||||
}
|
||||
pub fn with_bad(mut self, bad: Vec<&'a [u8]>) -> Self {
|
||||
self.header_bad = bad; self
|
||||
pub fn with_kv(mut self, v: Vec<header::Field<'a>>) -> Self {
|
||||
self.kv = v;
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -92,3 +89,65 @@ impl<'a> FromIterator<Field<'a>> for Imf<'a> {
|
|||
})
|
||||
}
|
||||
}
|
||||
|
||||
pub fn imf(input: &[u8]) -> IResult<&[u8], Imf> {
|
||||
map(header::header_kv, |fields| {
|
||||
fields
|
||||
.iter()
|
||||
.flat_map(Field::try_from)
|
||||
.into_iter()
|
||||
.collect::<Imf>()
|
||||
})(input)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::imf::address::*;
|
||||
use crate::imf::mailbox::*;
|
||||
use crate::text::misc_token::*;
|
||||
use chrono::{FixedOffset, TimeZone};
|
||||
|
||||
#[test]
|
||||
fn test_header() {
|
||||
let fullmail = b"Date: 7 Mar 2023 08:00:00 +0200
|
||||
From: someone@example.com
|
||||
To: someone_else@example.com
|
||||
Subject: An RFC 822 formatted message
|
||||
|
||||
This is the plain text body of the message. Note the blank line
|
||||
between the header information and the body of the message.";
|
||||
|
||||
assert_eq!(
|
||||
imf(fullmail),
|
||||
Ok((
|
||||
&b"This is the plain text body of the message. Note the blank line\nbetween the header information and the body of the message."[..],
|
||||
Imf {
|
||||
date: Some(FixedOffset::east_opt(2 * 3600).unwrap().with_ymd_and_hms(2023, 3, 7, 8, 0, 0).unwrap()),
|
||||
from: vec![MailboxRef {
|
||||
name: None,
|
||||
addrspec: AddrSpec {
|
||||
local_part: LocalPart(vec![LocalPartToken::Word(Word::Atom(&b"someone"[..]))]),
|
||||
domain: Domain::Atoms(vec![&b"example"[..], &b"com"[..]]),
|
||||
}
|
||||
}],
|
||||
to: vec![AddressRef::Single(MailboxRef {
|
||||
name: None,
|
||||
addrspec: AddrSpec {
|
||||
local_part: LocalPart(vec![LocalPartToken::Word(Word::Atom(&b"someone_else"[..]))]),
|
||||
domain: Domain::Atoms(vec![&b"example"[..], &b"com"[..]]),
|
||||
}
|
||||
})],
|
||||
subject: Some(Unstructured(vec![
|
||||
UnstrToken::Plain(&b"An"[..]),
|
||||
UnstrToken::Plain(&b"RFC"[..]),
|
||||
UnstrToken::Plain(&b"822"[..]),
|
||||
UnstrToken::Plain(&b"formatted"[..]),
|
||||
UnstrToken::Plain(&b"message"[..]),
|
||||
])),
|
||||
..Imf::default()
|
||||
}
|
||||
)),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
|
10
src/lib.rs
10
src/lib.rs
|
@ -18,7 +18,7 @@ pub mod text;
|
|||
/// Manipulate buffer of bytes
|
||||
mod pointers;
|
||||
|
||||
use nom::{IResult, combinator::into};
|
||||
use nom::{combinator::into, IResult};
|
||||
|
||||
/// Parse a whole email including its (MIME) body
|
||||
///
|
||||
|
@ -37,7 +37,7 @@ use nom::{IResult, combinator::into};
|
|||
/// * `msg` - The parsed message
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
///
|
||||
/// ```
|
||||
/// let input = br#"Date: 7 Mar 2023 08:00:00 +0200
|
||||
/// From: deuxfleurs@example.com
|
||||
|
@ -57,7 +57,9 @@ use nom::{IResult, combinator::into};
|
|||
/// );
|
||||
/// ```
|
||||
pub fn parse_message(input: &[u8]) -> IResult<&[u8], part::composite::Message> {
|
||||
into(part::composite::message(mime::MIME::<mime::r#type::DeductibleMessage>::default()))(input)
|
||||
into(part::composite::message(mime::MIME::<
|
||||
mime::r#type::DeductibleMessage,
|
||||
>::default()))(input)
|
||||
}
|
||||
|
||||
/// Only extract the headers of the email that are part of the Internet Message Format spec
|
||||
|
@ -98,5 +100,5 @@ pub fn parse_message(input: &[u8]) -> IResult<&[u8], part::composite::Message> {
|
|||
/// );
|
||||
/// ```
|
||||
pub fn parse_imf(input: &[u8]) -> IResult<&[u8], imf::Imf> {
|
||||
imf::field::imf(input)
|
||||
imf::imf(input)
|
||||
}
|
||||
|
|
|
@ -1,16 +1,10 @@
|
|||
use nom::{
|
||||
branch::alt,
|
||||
combinator::map,
|
||||
sequence::{preceded, terminated},
|
||||
IResult,
|
||||
};
|
||||
use nom::combinator::map;
|
||||
|
||||
use crate::header::{field_name};
|
||||
use crate::header;
|
||||
use crate::imf::identification::{msg_id, MessageID};
|
||||
use crate::mime::mechanism::{mechanism, Mechanism};
|
||||
use crate::mime::r#type::{naive_type, NaiveType};
|
||||
use crate::text::misc_token::{unstructured, Unstructured};
|
||||
use crate::text::whitespace::obs_crlf;
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub enum Content<'a> {
|
||||
|
@ -47,38 +41,38 @@ impl<'a> Content<'a> {
|
|||
}
|
||||
}
|
||||
|
||||
/*
|
||||
pub fn to_mime<'a, T: WithDefaultType>(list: Vec<Content<'a>>) -> AnyMIMEWithDefault<'a, T> {
|
||||
list.into_iter().collect::<AnyMIMEWithDefault<T>>()
|
||||
}*/
|
||||
impl<'a> TryFrom<&header::Field<'a>> for Content<'a> {
|
||||
type Error = ();
|
||||
fn try_from(f: &header::Field<'a>) -> Result<Self, Self::Error> {
|
||||
let content = match f {
|
||||
header::Field::Good(header::Kv2(key, value)) => match key
|
||||
.to_ascii_lowercase()
|
||||
.as_slice()
|
||||
{
|
||||
b"content-type" => map(naive_type, Content::Type)(value),
|
||||
b"content-transfer-encoding" => map(mechanism, Content::TransferEncoding)(value),
|
||||
b"content-id" => map(msg_id, Content::ID)(value),
|
||||
b"content-description" => map(unstructured, Content::Description)(value),
|
||||
_ => return Err(()),
|
||||
},
|
||||
_ => return Err(()),
|
||||
};
|
||||
|
||||
pub fn content(input: &[u8]) -> IResult<&[u8], Content> {
|
||||
terminated(
|
||||
alt((
|
||||
preceded(field_name(b"content-type"), map(naive_type, Content::Type)),
|
||||
preceded(
|
||||
field_name(b"content-transfer-encoding"),
|
||||
map(mechanism, Content::TransferEncoding),
|
||||
),
|
||||
preceded(field_name(b"content-id"), map(msg_id, Content::ID)),
|
||||
preceded(
|
||||
field_name(b"content-description"),
|
||||
map(unstructured, Content::Description),
|
||||
),
|
||||
)),
|
||||
obs_crlf,
|
||||
)(input)
|
||||
//@TODO check that the full value is parsed, otherwise maybe log an error ?!
|
||||
content.map(|(_, content)| content).or(Err(()))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::header::{header};
|
||||
use crate::mime::charset::EmailCharset;
|
||||
use crate::header;
|
||||
//use crate::mime::charset::EmailCharset;
|
||||
use crate::mime::r#type::*;
|
||||
use crate::text::misc_token::MIMEWord;
|
||||
use crate::text::quoted::QuotedString;
|
||||
|
||||
/*
|
||||
#[test]
|
||||
fn test_content_type() {
|
||||
let (rest, content) =
|
||||
|
@ -96,7 +90,7 @@ mod tests {
|
|||
} else {
|
||||
panic!("Expected Content::Type, got {:?}", content);
|
||||
}
|
||||
}
|
||||
}*/
|
||||
|
||||
#[test]
|
||||
fn test_header() {
|
||||
|
@ -116,7 +110,10 @@ This is a multipart message.
|
|||
.as_bytes();
|
||||
|
||||
assert_eq!(
|
||||
map(header(content), |(k, _, _)| k)(fullmail),
|
||||
map(header::header_kv, |k| k
|
||||
.iter()
|
||||
.flat_map(Content::try_from)
|
||||
.collect())(fullmail),
|
||||
Ok((
|
||||
&b"This is a multipart message.\n\n"[..],
|
||||
vec![
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/// Parsed and represent an email character set
|
||||
/// Parsed and represent an email character set
|
||||
pub mod charset;
|
||||
|
||||
/// MIME specific headers
|
||||
|
@ -10,19 +10,20 @@ pub mod mechanism;
|
|||
/// Content-Type representation
|
||||
pub mod r#type;
|
||||
|
||||
use std::fmt;
|
||||
use std::marker::PhantomData;
|
||||
|
||||
use crate::header;
|
||||
use crate::imf::identification::MessageID;
|
||||
use crate::mime::field::Content;
|
||||
use crate::mime::mechanism::Mechanism;
|
||||
use crate::mime::r#type::{AnyType, NaiveType};
|
||||
use crate::header;
|
||||
use crate::text::misc_token::Unstructured; //Multipart, Message, Text, Binary};
|
||||
|
||||
#[derive(Debug, PartialEq, Clone)]
|
||||
pub struct MIME<'a, T> {
|
||||
pub interpreted_type: T,
|
||||
pub fields: NaiveMIME<'a>
|
||||
pub interpreted_type: T,
|
||||
pub fields: NaiveMIME<'a>,
|
||||
}
|
||||
impl<'a> Default for MIME<'a, r#type::DeductibleText> {
|
||||
fn default() -> Self {
|
||||
|
@ -55,22 +56,32 @@ impl<'a, T: WithDefaultType> From<AnyMIMEWithDefault<'a, T>> for AnyMIME<'a> {
|
|||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Default, Clone)]
|
||||
#[derive(PartialEq, Default, Clone)]
|
||||
pub struct NaiveMIME<'a> {
|
||||
pub ctype: Option<NaiveType<'a>>,
|
||||
pub transfer_encoding: Mechanism<'a>,
|
||||
pub id: Option<MessageID<'a>>,
|
||||
pub description: Option<Unstructured<'a>>,
|
||||
pub header_ext: Vec<header::Kv<'a>>,
|
||||
pub header_bad: Vec<&'a [u8]>,
|
||||
pub kv: Vec<header::Field<'a>>,
|
||||
pub raw: &'a [u8],
|
||||
}
|
||||
impl<'a> fmt::Debug for NaiveMIME<'a> {
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
fmt.debug_struct("NaiveMime")
|
||||
.field("ctype", &self.ctype)
|
||||
.field("transfer_encoding", &self.transfer_encoding)
|
||||
.field("id", &self.id)
|
||||
.field("description", &self.description)
|
||||
.field("kv", &self.kv)
|
||||
.field("raw", &String::from_utf8_lossy(self.raw))
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> FromIterator<Content<'a>> for NaiveMIME<'a> {
|
||||
fn from_iter<I: IntoIterator<Item = Content<'a>>>(it: I) -> Self {
|
||||
it.into_iter().fold(
|
||||
NaiveMIME::default(),
|
||||
|mut section, field| {
|
||||
it.into_iter()
|
||||
.fold(NaiveMIME::default(), |mut section, field| {
|
||||
match field {
|
||||
Content::Type(v) => section.ctype = Some(v),
|
||||
Content::TransferEncoding(v) => section.transfer_encoding = v,
|
||||
|
@ -78,28 +89,29 @@ impl<'a> FromIterator<Content<'a>> for NaiveMIME<'a> {
|
|||
Content::Description(v) => section.description = Some(v),
|
||||
};
|
||||
section
|
||||
},
|
||||
)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> NaiveMIME<'a> {
|
||||
pub fn with_opt(mut self, opt: Vec<header::Kv<'a>>) -> Self {
|
||||
self.header_ext = opt; self
|
||||
}
|
||||
pub fn with_bad(mut self, bad: Vec<&'a [u8]>) -> Self {
|
||||
self.header_bad = bad; self
|
||||
pub fn with_kv(mut self, fields: Vec<header::Field<'a>>) -> Self {
|
||||
self.kv = fields;
|
||||
self
|
||||
}
|
||||
pub fn with_raw(mut self, raw: &'a [u8]) -> Self {
|
||||
self.raw = raw; self
|
||||
self.raw = raw;
|
||||
self
|
||||
}
|
||||
pub fn to_interpreted<T: WithDefaultType>(self) -> AnyMIME<'a> {
|
||||
self.ctype.as_ref().map(|c| c.to_type()).unwrap_or(T::default_type()).to_mime(self).into()
|
||||
self.ctype
|
||||
.as_ref()
|
||||
.map(|c| c.to_type())
|
||||
.unwrap_or(T::default_type())
|
||||
.to_mime(self)
|
||||
.into()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
pub trait WithDefaultType {
|
||||
fn default_type() -> AnyType;
|
||||
}
|
||||
|
|
|
@ -5,19 +5,29 @@ use nom::{
|
|||
sequence::{preceded, terminated, tuple},
|
||||
IResult,
|
||||
};
|
||||
use std::fmt;
|
||||
|
||||
use crate::mime::charset::EmailCharset;
|
||||
use crate::mime::{AnyMIME, NaiveMIME, MIME};
|
||||
use crate::text::misc_token::{mime_word, MIMEWord};
|
||||
use crate::text::words::mime_atom;
|
||||
use crate::mime::{AnyMIME, MIME, NaiveMIME};
|
||||
|
||||
// --------- NAIVE TYPE
|
||||
#[derive(Debug, PartialEq, Clone)]
|
||||
#[derive(PartialEq, Clone)]
|
||||
pub struct NaiveType<'a> {
|
||||
pub main: &'a [u8],
|
||||
pub sub: &'a [u8],
|
||||
pub params: Vec<Parameter<'a>>,
|
||||
}
|
||||
impl<'a> fmt::Debug for NaiveType<'a> {
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
fmt.debug_struct("mime::NaiveType")
|
||||
.field("main", &String::from_utf8_lossy(self.main))
|
||||
.field("sub", &String::from_utf8_lossy(self.sub))
|
||||
.field("params", &self.params)
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
impl<'a> NaiveType<'a> {
|
||||
pub fn to_type(&self) -> AnyType {
|
||||
self.into()
|
||||
|
@ -30,11 +40,20 @@ pub fn naive_type(input: &[u8]) -> IResult<&[u8], NaiveType> {
|
|||
)(input)
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Clone)]
|
||||
#[derive(PartialEq, Clone)]
|
||||
pub struct Parameter<'a> {
|
||||
pub name: &'a [u8],
|
||||
pub value: MIMEWord<'a>,
|
||||
}
|
||||
impl<'a> fmt::Debug for Parameter<'a> {
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
fmt.debug_struct("mime::Parameter")
|
||||
.field("name", &String::from_utf8_lossy(self.name))
|
||||
.field("value", &self.value)
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parameter(input: &[u8]) -> IResult<&[u8], Parameter> {
|
||||
map(
|
||||
tuple((mime_atom, tag(b"="), mime_word)),
|
||||
|
@ -73,16 +92,27 @@ impl<'a> From<&'a NaiveType<'a>> for AnyType {
|
|||
|
||||
impl<'a> AnyType {
|
||||
pub fn to_mime(self, fields: NaiveMIME<'a>) -> AnyMIME<'a> {
|
||||
match self {
|
||||
Self::Multipart(interpreted_type) => AnyMIME::Mult(MIME::<Multipart> { interpreted_type, fields }),
|
||||
Self::Message(interpreted_type) => AnyMIME::Msg(MIME::<DeductibleMessage> { interpreted_type, fields }),
|
||||
Self::Text(interpreted_type) => AnyMIME::Txt(MIME::<DeductibleText> { interpreted_type, fields }),
|
||||
Self::Binary(interpreted_type) => AnyMIME::Bin(MIME::<Binary> { interpreted_type, fields }),
|
||||
}
|
||||
match self {
|
||||
Self::Multipart(interpreted_type) => AnyMIME::Mult(MIME::<Multipart> {
|
||||
interpreted_type,
|
||||
fields,
|
||||
}),
|
||||
Self::Message(interpreted_type) => AnyMIME::Msg(MIME::<DeductibleMessage> {
|
||||
interpreted_type,
|
||||
fields,
|
||||
}),
|
||||
Self::Text(interpreted_type) => AnyMIME::Txt(MIME::<DeductibleText> {
|
||||
interpreted_type,
|
||||
fields,
|
||||
}),
|
||||
Self::Binary(interpreted_type) => AnyMIME::Bin(MIME::<Binary> {
|
||||
interpreted_type,
|
||||
fields,
|
||||
}),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#[derive(Debug, PartialEq, Clone)]
|
||||
pub enum Deductible<T: Default> {
|
||||
Inferred(T),
|
||||
|
@ -139,7 +169,8 @@ impl ToString for MultipartSubtype {
|
|||
Self::Parallel => "parallel",
|
||||
Self::Report => "report",
|
||||
Self::Unknown => "mixed",
|
||||
}.into()
|
||||
}
|
||||
.into()
|
||||
}
|
||||
}
|
||||
impl<'a> From<&NaiveType<'a>> for MultipartSubtype {
|
||||
|
@ -155,8 +186,6 @@ impl<'a> From<&NaiveType<'a>> for MultipartSubtype {
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
#[derive(Debug, PartialEq, Default, Clone)]
|
||||
pub enum MessageSubtype {
|
||||
#[default]
|
||||
|
@ -172,7 +201,8 @@ impl ToString for MessageSubtype {
|
|||
Self::Partial => "partial",
|
||||
Self::External => "external",
|
||||
Self::Unknown => "rfc822",
|
||||
}.into()
|
||||
}
|
||||
.into()
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -184,17 +214,25 @@ pub struct Message {
|
|||
impl<'a> From<&NaiveType<'a>> for Message {
|
||||
fn from(nt: &NaiveType<'a>) -> Self {
|
||||
match nt.sub.to_ascii_lowercase().as_slice() {
|
||||
b"rfc822" => Self { subtype: MessageSubtype::RFC822 },
|
||||
b"partial" => Self { subtype: MessageSubtype::Partial },
|
||||
b"external" => Self { subtype: MessageSubtype::External },
|
||||
_ => Self { subtype: MessageSubtype::Unknown },
|
||||
b"rfc822" => Self {
|
||||
subtype: MessageSubtype::RFC822,
|
||||
},
|
||||
b"partial" => Self {
|
||||
subtype: MessageSubtype::Partial,
|
||||
},
|
||||
b"external" => Self {
|
||||
subtype: MessageSubtype::External,
|
||||
},
|
||||
_ => Self {
|
||||
subtype: MessageSubtype::Unknown,
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
impl From<Deductible<Message>> for Message {
|
||||
fn from(d: Deductible<Message>) -> Self {
|
||||
match d {
|
||||
Deductible::Inferred(t) | Deductible::Explicit(t) => t
|
||||
Deductible::Inferred(t) | Deductible::Explicit(t) => t,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -221,7 +259,7 @@ impl<'a> From<&NaiveType<'a>> for Text {
|
|||
impl From<Deductible<Text>> for Text {
|
||||
fn from(d: Deductible<Text>) -> Self {
|
||||
match d {
|
||||
Deductible::Inferred(t) | Deductible::Explicit(t) => t
|
||||
Deductible::Inferred(t) | Deductible::Explicit(t) => t,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -238,7 +276,8 @@ impl ToString for TextSubtype {
|
|||
match self {
|
||||
Self::Plain | Self::Unknown => "plain",
|
||||
Self::Html => "html",
|
||||
}.into()
|
||||
}
|
||||
.into()
|
||||
}
|
||||
}
|
||||
impl<'a> From<&NaiveType<'a>> for TextSubtype {
|
||||
|
@ -258,8 +297,8 @@ pub struct Binary {}
|
|||
mod tests {
|
||||
use super::*;
|
||||
use crate::mime::charset::EmailCharset;
|
||||
use crate::text::quoted::QuotedString;
|
||||
use crate::mime::r#type::Deductible;
|
||||
use crate::text::quoted::QuotedString;
|
||||
|
||||
#[test]
|
||||
fn test_parameter() {
|
||||
|
@ -317,7 +356,12 @@ mod tests {
|
|||
let (rest, nt) = naive_type(b"message/rfc822").unwrap();
|
||||
assert_eq!(rest, &[]);
|
||||
|
||||
assert_eq!(nt.to_type(), AnyType::Message(Deductible::Explicit(Message { subtype: MessageSubtype::RFC822 })));
|
||||
assert_eq!(
|
||||
nt.to_type(),
|
||||
AnyType::Message(Deductible::Explicit(Message {
|
||||
subtype: MessageSubtype::RFC822
|
||||
}))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
@ -1,20 +1,37 @@
|
|||
use nom::IResult;
|
||||
use std::fmt;
|
||||
|
||||
use crate::header::{header, self};
|
||||
use crate::header;
|
||||
use crate::imf;
|
||||
use crate::mime;
|
||||
use crate::part::{self, AnyPart, field::MixedField};
|
||||
use crate::text::boundary::{boundary, Delimiter};
|
||||
use crate::part::{self, AnyPart};
|
||||
use crate::pointers;
|
||||
use crate::text::boundary::{boundary, Delimiter};
|
||||
|
||||
//--- Multipart
|
||||
#[derive(Debug, PartialEq)]
|
||||
#[derive(PartialEq)]
|
||||
pub struct Multipart<'a> {
|
||||
pub mime: mime::MIME<'a, mime::r#type::Multipart>,
|
||||
pub children: Vec<AnyPart<'a>>,
|
||||
pub raw_part_inner: &'a [u8],
|
||||
pub raw_part_outer: &'a [u8],
|
||||
}
|
||||
impl<'a> fmt::Debug for Multipart<'a> {
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
fmt.debug_struct("part::Multipart")
|
||||
.field("mime", &self.mime)
|
||||
.field("children", &self.children)
|
||||
.field(
|
||||
"raw_part_inner",
|
||||
&String::from_utf8_lossy(self.raw_part_inner),
|
||||
)
|
||||
.field(
|
||||
"raw_part_outer",
|
||||
&String::from_utf8_lossy(self.raw_part_outer),
|
||||
)
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
impl<'a> Multipart<'a> {
|
||||
pub fn preamble(&self) -> &'a [u8] {
|
||||
pointers::parsed(self.raw_part_outer, self.raw_part_inner)
|
||||
|
@ -65,7 +82,10 @@ pub fn multipart<'a>(
|
|||
mime: m.clone(),
|
||||
children: mparts,
|
||||
raw_part_inner: pointers::parsed(inner_orig, inp),
|
||||
raw_part_outer: pointers::parsed(outer_orig, &outer_orig[outer_orig.len()..]),
|
||||
raw_part_outer: pointers::parsed(
|
||||
outer_orig,
|
||||
&outer_orig[outer_orig.len()..],
|
||||
),
|
||||
},
|
||||
))
|
||||
}
|
||||
|
@ -73,24 +93,30 @@ pub fn multipart<'a>(
|
|||
};
|
||||
|
||||
// parse mime headers, otherwise pick default mime
|
||||
let (input, naive_mime) = match header(mime::field::content)(input) {
|
||||
Ok((input_eom, (known, unknown, bad))) => {
|
||||
let (input, naive_mime) = match header::header_kv(input) {
|
||||
Ok((input_eom, fields)) => {
|
||||
let raw_hdrs = pointers::parsed(input, input_eom);
|
||||
let mime = known
|
||||
let mime = fields
|
||||
.iter()
|
||||
.flat_map(mime::field::Content::try_from)
|
||||
.into_iter()
|
||||
.collect::<mime::NaiveMIME>()
|
||||
.with_opt(unknown)
|
||||
.with_bad(bad)
|
||||
.with_raw(raw_hdrs);
|
||||
.collect::<mime::NaiveMIME>();
|
||||
|
||||
let mime = mime.with_kv(fields).with_raw(raw_hdrs);
|
||||
|
||||
(input_eom, mime)
|
||||
},
|
||||
}
|
||||
Err(_) => (input, mime::NaiveMIME::default()),
|
||||
};
|
||||
|
||||
// interpret mime according to context
|
||||
let mime = match m.interpreted_type.subtype {
|
||||
mime::r#type::MultipartSubtype::Digest => naive_mime.to_interpreted::<mime::WithDigestDefault>().into(),
|
||||
_ => naive_mime.to_interpreted::<mime::WithGenericDefault>().into(),
|
||||
mime::r#type::MultipartSubtype::Digest => naive_mime
|
||||
.to_interpreted::<mime::WithDigestDefault>()
|
||||
.into(),
|
||||
_ => naive_mime
|
||||
.to_interpreted::<mime::WithGenericDefault>()
|
||||
.into(),
|
||||
};
|
||||
|
||||
// parse raw part
|
||||
|
@ -109,7 +135,7 @@ pub fn multipart<'a>(
|
|||
|
||||
//--- Message
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
#[derive(PartialEq)]
|
||||
pub struct Message<'a> {
|
||||
pub mime: mime::MIME<'a, mime::r#type::DeductibleMessage>,
|
||||
pub imf: imf::Imf<'a>,
|
||||
|
@ -119,6 +145,18 @@ pub struct Message<'a> {
|
|||
pub raw_headers: &'a [u8],
|
||||
pub raw_body: &'a [u8],
|
||||
}
|
||||
impl<'a> fmt::Debug for Message<'a> {
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
fmt.debug_struct("part::Message")
|
||||
.field("mime", &self.mime)
|
||||
.field("imf", &self.imf)
|
||||
.field("child", &self.child)
|
||||
.field("raw_part", &String::from_utf8_lossy(self.raw_part))
|
||||
.field("raw_headers", &String::from_utf8_lossy(self.raw_headers))
|
||||
.field("raw_body", &String::from_utf8_lossy(self.raw_body))
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn message<'a>(
|
||||
m: mime::MIME<'a, mime::r#type::DeductibleMessage>,
|
||||
|
@ -127,23 +165,27 @@ pub fn message<'a>(
|
|||
let orig = input;
|
||||
|
||||
// parse header fields
|
||||
let (input, (known, unknown, bad)): (_, (Vec::<MixedField>, Vec<header::Kv>, Vec<&[u8]>)) =
|
||||
header(part::field::mixed_field)(input)?;
|
||||
let (input, headers) = header::header_kv(input)?;
|
||||
|
||||
// extract raw parts 1/2
|
||||
let raw_headers = pointers::parsed(orig, input);
|
||||
let body_orig = input;
|
||||
|
||||
//---------------
|
||||
// aggregate header fields
|
||||
let (naive_mime, imf) = part::field::sections(known);
|
||||
let (naive_mime, imf) = part::field::split_and_build(&headers);
|
||||
|
||||
// attach bad headers to imf
|
||||
let imf = imf.with_opt(unknown).with_bad(bad);
|
||||
// Bind headers to the IMF object
|
||||
let imf = imf.with_kv(headers);
|
||||
|
||||
// interpret headers to choose a mime type
|
||||
let in_mime = naive_mime.with_raw(raw_headers).to_interpreted::<mime::WithGenericDefault>().into();
|
||||
let in_mime = naive_mime
|
||||
.with_raw(raw_headers)
|
||||
.to_interpreted::<mime::WithGenericDefault>()
|
||||
.into();
|
||||
//---------------
|
||||
|
||||
// parse this mimetype
|
||||
// parse a part following this mime specification
|
||||
let (input, part) = part::anypart(in_mime)(input)?;
|
||||
|
||||
// extract raw parts 2/2
|
||||
|
@ -155,7 +197,9 @@ pub fn message<'a>(
|
|||
Message {
|
||||
mime: m.clone(),
|
||||
imf,
|
||||
raw_part, raw_headers, raw_body,
|
||||
raw_part,
|
||||
raw_headers,
|
||||
raw_body,
|
||||
child: Box::new(part),
|
||||
},
|
||||
))
|
||||
|
@ -168,7 +212,7 @@ mod tests {
|
|||
use crate::part::discrete::Text;
|
||||
use crate::part::AnyPart;
|
||||
use crate::text::encoding::{Base64Word, EncodedWord, QuotedChunk, QuotedWord};
|
||||
use crate::text::misc_token::{Phrase, UnstrToken, Unstructured, Word, MIMEWord};
|
||||
use crate::text::misc_token::{MIMEWord, Phrase, UnstrToken, Unstructured, Word};
|
||||
use crate::text::quoted::QuotedString;
|
||||
use chrono::{FixedOffset, TimeZone};
|
||||
|
||||
|
@ -229,12 +273,15 @@ It DOES end with a linebreak.
|
|||
subtype: mime::r#type::TextSubtype::Plain,
|
||||
charset: mime::r#type::Deductible::Inferred(mime::charset::EmailCharset::US_ASCII),
|
||||
}),
|
||||
fields: mime::NaiveMIME::default(),
|
||||
fields: mime::NaiveMIME {
|
||||
raw: &b"\n"[..],
|
||||
..mime::NaiveMIME::default()
|
||||
},
|
||||
},
|
||||
body: &b"This is implicitly typed plain US-ASCII text.\nIt does NOT end with a linebreak."[..],
|
||||
}),
|
||||
AnyPart::Txt(Text {
|
||||
mime: mime::MIME {
|
||||
mime: mime::MIME {
|
||||
interpreted_type: mime::r#type::Deductible::Explicit(mime::r#type::Text {
|
||||
subtype: mime::r#type::TextSubtype::Plain,
|
||||
charset: mime::r#type::Deductible::Explicit(mime::charset::EmailCharset::US_ASCII),
|
||||
|
@ -250,6 +297,10 @@ It DOES end with a linebreak.
|
|||
}
|
||||
]
|
||||
}),
|
||||
raw: &b"Content-type: text/plain; charset=us-ascii\n\n"[..],
|
||||
kv: vec![
|
||||
header::Field::Good(header::Kv2(&b"Content-type"[..], &b"text/plain; charset=us-ascii"[..]))
|
||||
],
|
||||
..mime::NaiveMIME::default()
|
||||
},
|
||||
},
|
||||
|
@ -455,14 +506,18 @@ OoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoO<br />
|
|||
right: &b"www.grrrndzero.org"[..],
|
||||
}),
|
||||
mime_version: Some(imf::mime::Version { major: 1, minor: 0}),
|
||||
header_ext: vec![
|
||||
header::Kv(&b"X-Unknown"[..], Unstructured(vec![
|
||||
UnstrToken::Plain(&b"something"[..]),
|
||||
UnstrToken::Plain(&b"something"[..]),
|
||||
]))
|
||||
],
|
||||
header_bad: vec![
|
||||
&b"Bad entry\n on multiple lines\n"[..],
|
||||
kv: vec![
|
||||
header::Field::Good(header::Kv2(&b"Date"[..], &b"Sat, 8 Jul 2023 07:14:29 +0200"[..])),
|
||||
header::Field::Good(header::Kv2(&b"From"[..], &b"Grrrnd Zero <grrrndzero@example.org>"[..])),
|
||||
header::Field::Good(header::Kv2(&b"To"[..], &b"John Doe <jdoe@machine.example>"[..])),
|
||||
header::Field::Good(header::Kv2(&b"CC"[..], &b"=?ISO-8859-1?Q?Andr=E9?= Pirard <PIRARD@vm1.ulg.ac.be>"[..])),
|
||||
header::Field::Good(header::Kv2(&b"Subject"[..], &b"=?ISO-8859-1?B?SWYgeW91IGNhbiByZWFkIHRoaXMgeW8=?=\n =?ISO-8859-2?B?dSB1bmRlcnN0YW5kIHRoZSBleGFtcGxlLg==?="[..])),
|
||||
header::Field::Good(header::Kv2(&b"X-Unknown"[..], &b"something something"[..])),
|
||||
header::Field::Bad(&b"Bad entry\n on multiple lines\n"[..]),
|
||||
header::Field::Good(header::Kv2(&b"Message-ID"[..], &b"<NTAxNzA2AC47634Y366BAMTY4ODc5MzQyODY0ODY5@www.grrrndzero.org>"[..])),
|
||||
header::Field::Good(header::Kv2(&b"MIME-Version"[..], &b"1.0"[..])),
|
||||
header::Field::Good(header::Kv2(&b"Content-Type"[..], &b"multipart/alternative;\n boundary=\"b1_e376dc71bafc953c0b0fdeb9983a9956\""[..])),
|
||||
header::Field::Good(header::Kv2(&b"Content-Transfer-Encoding"[..], &b"7bit"[..])),
|
||||
],
|
||||
..imf::Imf::default()
|
||||
},
|
||||
|
@ -483,6 +538,7 @@ OoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoO<br />
|
|||
}
|
||||
]
|
||||
}),
|
||||
raw: hdrs,
|
||||
..mime::NaiveMIME::default()
|
||||
},
|
||||
},
|
||||
|
@ -507,6 +563,11 @@ OoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoO<br />
|
|||
]
|
||||
}),
|
||||
transfer_encoding: mime::mechanism::Mechanism::QuotedPrintable,
|
||||
kv: vec![
|
||||
header::Field::Good(header::Kv2(&b"Content-Type"[..], &b"text/plain; charset=utf-8"[..])),
|
||||
header::Field::Good(header::Kv2(&b"Content-Transfer-Encoding"[..], &b"quoted-printable"[..])),
|
||||
],
|
||||
raw: &b"Content-Type: text/plain; charset=utf-8\nContent-Transfer-Encoding: quoted-printable\n\n"[..],
|
||||
..mime::NaiveMIME::default()
|
||||
}
|
||||
},
|
||||
|
@ -529,7 +590,11 @@ OoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoO<br />
|
|||
value: MIMEWord::Atom(&b"us-ascii"[..]),
|
||||
}
|
||||
]
|
||||
}),
|
||||
}),
|
||||
kv: vec![
|
||||
header::Field::Good(header::Kv2(&b"Content-Type"[..], &b"text/html; charset=us-ascii"[..])),
|
||||
],
|
||||
raw: &b"Content-Type: text/html; charset=us-ascii\n\n"[..],
|
||||
..mime::NaiveMIME::default()
|
||||
},
|
||||
},
|
||||
|
|
|
@ -12,10 +12,7 @@ impl<'a> fmt::Debug for Text<'a> {
|
|||
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
fmt.debug_struct("part::Text")
|
||||
.field("mime", &self.mime)
|
||||
.field(
|
||||
"body",
|
||||
&format_args!("\"{}\"", String::from_utf8_lossy(self.body)),
|
||||
)
|
||||
.field("body", &String::from_utf8_lossy(self.body))
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
@ -30,10 +27,7 @@ impl<'a> fmt::Debug for Binary<'a> {
|
|||
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
fmt.debug_struct("part::Binary")
|
||||
.field("mime", &self.mime)
|
||||
.field(
|
||||
"body",
|
||||
&format_args!("\"{}\"", String::from_utf8_lossy(self.body)),
|
||||
)
|
||||
.field("body", &String::from_utf8_lossy(self.body))
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,50 +1,24 @@
|
|||
use nom::{branch::alt, combinator::map, IResult};
|
||||
|
||||
use crate::header;
|
||||
use crate::imf;
|
||||
use crate::mime;
|
||||
|
||||
pub enum MixedField<'a> {
|
||||
MIME(mime::field::Content<'a>),
|
||||
IMF(imf::field::Field<'a>),
|
||||
}
|
||||
#[allow(dead_code)]
|
||||
impl<'a> MixedField<'a> {
|
||||
pub fn mime(&self) -> Option<&mime::field::Content<'a>> {
|
||||
match self {
|
||||
Self::MIME(v) => Some(v),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
pub fn to_mime(self) -> Option<mime::field::Content<'a>> {
|
||||
match self {
|
||||
Self::MIME(v) => Some(v),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
pub fn imf(&self) -> Option<&imf::field::Field<'a>> {
|
||||
match self {
|
||||
Self::IMF(v) => Some(v),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
pub fn to_imf(self) -> Option<imf::field::Field<'a>> {
|
||||
match self {
|
||||
Self::IMF(v) => Some(v),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
pub fn split_and_build<'a>(v: &Vec<header::Field<'a>>) -> (mime::NaiveMIME<'a>, imf::Imf<'a>) {
|
||||
let (mimev, imfv) = v.iter().fold(
|
||||
(
|
||||
Vec::<mime::field::Content>::new(),
|
||||
Vec::<imf::field::Field>::new(),
|
||||
),
|
||||
|(mut mime, mut imf), f| {
|
||||
if let Ok(m) = mime::field::Content::try_from(f) {
|
||||
mime.push(m);
|
||||
} else if let Ok(i) = imf::field::Field::try_from(f) {
|
||||
imf.push(i);
|
||||
}
|
||||
(mime, imf)
|
||||
},
|
||||
);
|
||||
|
||||
pub fn sections<'a>(list: Vec<MixedField<'a>>) -> (mime::NaiveMIME<'a>, imf::Imf<'a>) {
|
||||
let (v1, v2): (Vec<MixedField>, Vec<_>) = list.into_iter().partition(|v| v.mime().is_some());
|
||||
let mime = v1.into_iter().flat_map(MixedField::to_mime).collect::<mime::NaiveMIME>();
|
||||
let imf = v2.into_iter().flat_map(MixedField::to_imf).collect::<imf::Imf>();
|
||||
(mime, imf)
|
||||
}
|
||||
|
||||
pub fn mixed_field(input: &[u8]) -> IResult<&[u8], MixedField> {
|
||||
alt((
|
||||
map(mime::field::content, MixedField::MIME),
|
||||
map(imf::field::field, MixedField::IMF),
|
||||
))(input)
|
||||
let fmime = mimev.into_iter().collect::<mime::NaiveMIME>();
|
||||
let fimf = imfv.into_iter().collect::<imf::Imf>();
|
||||
(fmime, fimf)
|
||||
}
|
||||
|
|
|
@ -80,18 +80,19 @@ pub fn anypart<'a>(m: AnyMIME<'a>) -> impl FnOnce(&'a [u8]) -> IResult<&'a [u8],
|
|||
move |input| {
|
||||
let part = match m {
|
||||
AnyMIME::Mult(a) => multipart(a)(input)
|
||||
.map(|(_, multi)|
|
||||
multi.into())
|
||||
.unwrap_or(AnyPart::Txt(Text {
|
||||
mime: mime::MIME::<mime::r#type::DeductibleText>::default(),
|
||||
body: input,
|
||||
})),
|
||||
AnyMIME::Msg(a) => message(a)(input)
|
||||
.map(|(_, msg)| msg.into())
|
||||
.map(|(_, multi)| multi.into())
|
||||
.unwrap_or(AnyPart::Txt(Text {
|
||||
mime: mime::MIME::<mime::r#type::DeductibleText>::default(),
|
||||
body: input,
|
||||
})),
|
||||
AnyMIME::Msg(a) => {
|
||||
message(a)(input)
|
||||
.map(|(_, msg)| msg.into())
|
||||
.unwrap_or(AnyPart::Txt(Text {
|
||||
mime: mime::MIME::<mime::r#type::DeductibleText>::default(),
|
||||
body: input,
|
||||
}))
|
||||
}
|
||||
AnyMIME::Txt(a) => AnyPart::Txt(Text {
|
||||
mime: a,
|
||||
body: input,
|
||||
|
@ -101,7 +102,7 @@ pub fn anypart<'a>(m: AnyMIME<'a>) -> impl FnOnce(&'a [u8]) -> IResult<&'a [u8],
|
|||
body: input,
|
||||
}),
|
||||
};
|
||||
|
||||
|
||||
// This function always consumes the whole input
|
||||
Ok((&input[input.len()..], part))
|
||||
}
|
||||
|
|
|
@ -22,7 +22,12 @@ use nom::{
|
|||
/// \r or \n is allowed nowhere else, so we also add this support.
|
||||
|
||||
pub fn obs_crlf(input: &[u8]) -> IResult<&[u8], &[u8]> {
|
||||
alt((tag(ascii::CRLF), tag(ascii::CRCRLF), tag(&[ascii::CR]), tag(&[ascii::LF])))(input)
|
||||
alt((
|
||||
tag(ascii::CRLF),
|
||||
tag(ascii::CRCRLF),
|
||||
tag(&[ascii::CR]),
|
||||
tag(&[ascii::LF]),
|
||||
))(input)
|
||||
}
|
||||
|
||||
/// ```abnf
|
||||
|
|
Loading…
Reference in a new issue