For mails forwarded by `proxmox-mail-forward` to an SMTP target, the
original message was nested as a 'message/rfc822' message part.
Originally this approach was chosen to avoid having to rewrite
message headers.
Good email-clients, such as Thunderbird can display these inline.
Other, more limited clients will show these messages as an attached
.eml file, which is not really a good user experience.
This patch changes the approach for message forwarding to be more like
forwarding mails in a mail client. We create a new message and
add the original message body as a body. Additionally, we also copy
over all message headers that are relevant to correctly display the
original message body (e.g. Content-Type, Content-Transfer-Encoding)
Tested with a couple of different email messages (varying in
structure, body parts, encoding, etc.) against the following SMTP
relays:
- gmail
- outlook
- our own webmail service
Originally reported in our community forum:
https://forum.proxmox.com/threads/proxmox-mail-forward-sends-mails-as-eml.137710/
Signed-off-by: Lukas Wagner <[email protected]>
---
Notes:
proxmox-mail-forward needs a bump once this is applied.
proxmox-notify/src/endpoints/smtp.rs | 99 ++++++++++++++++++++++++----
1 file changed, 88 insertions(+), 11 deletions(-)
diff --git a/proxmox-notify/src/endpoints/smtp.rs
b/proxmox-notify/src/endpoints/smtp.rs
index 064c9f9..4b8ff2d 100644
--- a/proxmox-notify/src/endpoints/smtp.rs
+++ b/proxmox-notify/src/endpoints/smtp.rs
@@ -1,8 +1,9 @@
+use std::time::Duration;
+
use lettre::message::{Mailbox, MultiPart, SinglePart};
use lettre::transport::smtp::client::{Tls, TlsParameters};
use lettre::{message::header::ContentType, Message, SmtpTransport, Transport};
use serde::{Deserialize, Serialize};
-use std::time::Duration;
use proxmox_schema::api_types::COMMENT_SCHEMA;
use proxmox_schema::{api, Updater};
@@ -231,17 +232,93 @@ impl Endpoint for SmtpEndpoint {
}
#[cfg(feature = "mail-forwarder")]
Content::ForwardedMail { ref raw, title, .. } => {
- email_builder = email_builder.subject(title);
+ use lettre::message::header::{ContentTransferEncoding,
HeaderName, HeaderValue};
+ use lettre::message::Body;
- // Forwarded messages are embedded inline as 'message/rfc822'
- // this let's us avoid rewriting any headers (e.g. From)
- email_builder
- .singlepart(
- SinglePart::builder()
-
.header(ContentType::parse("message/rfc822").unwrap())
- .body(raw.to_owned()),
- )
- .map_err(|err| Error::NotifyFailed(self.name().into(),
Box::new(err)))?
+ let parsed_message = mail_parser::Message::parse(raw)
+ .ok_or_else(|| Error::Generic("could not parse forwarded
email".to_string()))?;
+
+ let root_part = parsed_message
+ .part(0)
+ .ok_or_else(|| Error::Generic("root message part not
present".to_string()))?;
+
+ let raw_body = parsed_message
+ .raw_message()
+ .get(root_part.offset_body..root_part.offset_end)
+ .ok_or_else(|| Error::Generic("could not get raw body
content".to_string()))?;
+
+ // We assume that the original message content is already
properly
+ // encoded, thus we add the original message body 'Binary'
encoding.
+ // This prohibits lettre from trying to re-encode our raw body
data.
+ // lettre will automatically set the
`Content-Transfer-Encoding: binary` header,
+ // which we need to remove. The actual transfer encoding is
later
+ // copied from the original message headers.
+ let body =
+ Body::new_with_encoding(raw_body.to_vec(),
ContentTransferEncoding::Binary)
+ .map_err(|_| Error::Generic("could not create
body".into()))?;
+ let mut message = email_builder
+ .subject(title)
+ .body(body)
+ .map_err(|err| Error::NotifyFailed(self.name().into(),
Box::new(err)))?;
+ message
+ .headers_mut()
+ .remove_raw("Content-Transfer-Encoding");
+
+ // Copy over all headers that are relevant to display the
original body correctly.
+ // Unfortunately this is a bit cumbersome, as we use separate
crates for mail parsing (mail-parser)
+ // and creating/sending mails (lettre).
+ // Note: Other MIME-Headers, such as
Content-{ID,Description,Disposition} are only used
+ // for body-parts in multipart messages, so we can ignore them
for the messages headers.
+ // Since we send the original raw body, the part-headers will
be included any way.
+ for header in parsed_message.headers() {
+ let header_name = header.name.as_str();
+ // Email headers are case-insensitive, so convert to
lowercase...
+ let value = match header_name.to_lowercase().as_str() {
+ "content-type" => {
+ if let mail_parser::HeaderValue::ContentType(ct) =
header.value() {
+ // mail_parser does not give us access to the
full decoded and unfolded
+ // header value, so we unfortunately need to
reassemble it ourselves.
+ // Meh.
