Prepare 0.10.0-rc.1 (#620)

* Add InvalidHeaderName error

.github/workflows/test.yml

@@ -79,8 +79,8 @@ jobs:
             rust: stable
           - name: beta
             rust: beta
-          - name: 1.45.2
-            rust: 1.45.2
+          - name: 1.46.0
+            rust: 1.46.0
 
     steps:
       - name: Checkout

CHANGELOG.md

@@ -5,7 +5,7 @@
 
 Several breaking changes were made between 0.9 and 0.10, but changes should be straightforward:
 
-* MSRV is now 1.45.2
+* MSRV is now 1.46
 * The `lettre_email` crate has been merged into `lettre`. To migrate, replace `lettre_email` with `lettre::message`
   and make sure to enable the `builder` feature (it's enabled by default).
 * `SendableEmail` has been renamed to `Email` and `EmailBuilder::build()` produces it directly. To migrate,
@@ -14,7 +14,7 @@ Several breaking changes were made between 0.9 and 0.10, but changes should be s
 
 #### Features
 
-* Add `tokio` 0.2 and 1.0 support
+* Add `tokio` 1 support
 * Add `rustls` support
 * Add `async-std` support. NOTE: native-tls isn't supported when using async-std for the smtp transport.
 * Allow enabling multiple SMTP authentication mechanisms

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "lettre"
 # remember to update html_root_url and README.md (Cargo.toml example and deps.rs badge)
-version = "0.10.0-beta.3"
+version = "0.10.0-rc.1"
 description = "Email client"
 readme = "README.md"
 homepage = "https://lettre.rs"
@@ -22,16 +22,16 @@ idna = "0.2"
 tracing = { version = "0.1.16", default-features = false, features = ["std"], optional = true } # feature
 
 # builder
-hyperx = { version = "1", optional = true, features = ["headers"] }
+httpdate = { version = "1", optional = true }
 mime = { version = "0.3.4", optional = true }
-uuid = { version = "0.8", features = ["v4"] }
-rand = { version = "0.8", optional = true }
+fastrand = { version = "1.4", optional = true }
 quoted_printable = { version = "0.4", optional = true }
 base64 = { version = "0.13", optional = true }
 once_cell = "1"
 regex = { version = "1", default-features = false, features = ["std", "unicode-case"] }
 
 # file transport
+uuid = { version = "0.8", features = ["v4"], optional = true }
 serde = { version = "1", optional = true, features = ["derive"] }
 serde_json = { version = "1", optional = true }
 
@@ -57,9 +57,6 @@ async-std = { version = "1.8", optional = true, features = ["unstable"] }
 async-rustls = { version = "0.2", optional = true }
 
 ## tokio
-tokio02_crate = { package = "tokio", version = "0.2.7", features = ["fs", "process", "tcp", "dns", "io-util"], optional = true }
-tokio02_native_tls_crate = { package = "tokio-native-tls", version = "0.1", optional = true }
-tokio02_rustls = { package = "tokio-rustls", version = "0.15", optional = true }
 tokio1_crate = { package = "tokio", version = "1", features = ["fs", "process", "net", "io-util"], optional = true }
 tokio1_native_tls_crate = { package = "tokio-native-tls", version = "0.3", optional = true }
 tokio1_rustls = { package = "tokio-rustls", version = "0.22", optional = true }
@@ -69,7 +66,6 @@ criterion = "0.3"
 tracing-subscriber = "0.2.10"
 glob = "0.3"
 walkdir = "2"
-tokio02_crate = { package = "tokio", version = "0.2.7", features = ["macros", "rt-threaded"] }
 tokio1_crate = { package = "tokio", version = "1", features = ["macros", "rt-multi-thread"] }
 async-std = { version = "1.8", features = ["attributes"] }
 serde_json = "1"
@@ -81,10 +77,10 @@ name = "transport_smtp"
 
 [features]
 default = ["smtp-transport", "native-tls", "hostname", "r2d2", "builder"]
-builder = ["mime", "base64", "hyperx", "rand", "quoted_printable"]
+builder = ["httpdate", "mime", "base64", "fastrand", "quoted_printable"]
 
 # transports
-file-transport = []
+file-transport = ["uuid"]
 file-transport-envelope = ["serde", "serde_json", "file-transport"]
 sendmail-transport = []
 smtp-transport = ["base64", "nom"]
@@ -95,9 +91,6 @@ rustls-tls = ["webpki", "webpki-roots", "rustls"]
 async-std1 = ["async-std", "async-trait", "futures-io", "futures-util"]
 #async-std1-native-tls = ["async-std1", "native-tls", "async-native-tls"]
 async-std1-rustls-tls = ["async-std1", "rustls-tls", "async-rustls"]
-tokio02 = ["tokio02_crate", "async-trait", "futures-io", "futures-util"]
-tokio02-native-tls = ["tokio02", "native-tls", "tokio02_native_tls_crate"]
-tokio02-rustls-tls = ["tokio02", "rustls-tls", "tokio02_rustls"]
 tokio1 = ["tokio1_crate", "async-trait", "futures-io", "futures-util"]
 tokio1-native-tls = ["tokio1", "native-tls", "tokio1_native_tls_crate"]
 tokio1-rustls-tls = ["tokio1", "rustls-tls", "tokio1_rustls"]
@@ -130,14 +123,6 @@ required-features = ["smtp-transport", "native-tls", "builder"]
 name = "smtp_selfsigned"
 required-features = ["smtp-transport", "native-tls", "builder"]
 
-[[example]]
-name = "tokio02_smtp_tls"
-required-features = ["smtp-transport", "tokio02", "tokio02-native-tls", "builder"]
-
-[[example]]
-name = "tokio02_smtp_starttls"
-required-features = ["smtp-transport", "tokio02", "tokio02-native-tls", "builder"]
-
 [[example]]
 name = "tokio1_smtp_tls"
 required-features = ["smtp-transport", "tokio1", "tokio1-native-tls", "builder"]

README.md

@@ -28,8 +28,8 @@
 </div>
 
 <div align="center">
-  <a href="https://deps.rs/crate/lettre/0.10.0-beta.3">
-    <img src="https://deps.rs/crate/lettre/0.10.0-beta.3/status.svg"
+  <a href="https://deps.rs/crate/lettre/0.10.0-rc.1">
+    <img src="https://deps.rs/crate/lettre/0.10.0-rc.1/status.svg"
       alt="dependency status" />
   </a>
 </div>
@@ -37,10 +37,15 @@
 ---
 
 **NOTE**: this readme refers to the 0.10 version of lettre, which is
-still being worked on. The master branch and the alpha releases will see
-API breaking changes and some features may be missing or incomplete until
-the stable 0.10.0 release is out.
-Use the [`v0.9.x`](https://github.com/lettre/lettre/tree/v0.9.x) branch for stable releases.
+in release candidate state. Use the [`v0.9.x`](https://github.com/lettre/lettre/tree/v0.9.x)
+branch for the previous stable release.
+
+0.10 is already widely used and is already thought to be more reliable than 0.9, so it should generally be used
+for new projects.
+
+We'd love to hear your feedback about 0.10 design and APIs before final release!
+Start a [discussion](https://github.com/lettre/lettre/discussions) in the repository, whether for
+feedback or if you need help or advice using or upgrading lettre 0.10.
 
 ---
 
@@ -60,13 +65,13 @@ Lettre does not provide (for now):
 
 ## Example
 
-This library requires Rust 1.45 or newer.
+This library requires Rust 1.46 or newer.
 To use this library, add the following to your `Cargo.toml`:
 
 
 ```toml
 [dependencies]
-lettre = "0.10.0-beta.3"
+lettre = "0.10.0-rc.1"
 ```
 
 ```rust,no_run
@@ -78,7 +83,7 @@ let email = Message::builder()
     .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
     .to("Hei <hei@domain.tld>".parse().unwrap())
     .subject("Happy new year")
-    .body("Be happy!")
+    .body(String::from("Be happy!"))
     .unwrap();
 
 let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());

examples/README.md

@@ -14,7 +14,7 @@ This folder contains examples showing how to use lettre in your own projects.
 - [smtp_starttls.rs] - Send an email over SMTP with STARTTLS and authenticating with username and password.
 - [smtp_selfsigned.rs] - Send an email over SMTP encrypted with TLS using a self-signed certificate and authenticating with username and password.
 - The [smtp_tls.rs] and [smtp_starttls.rs] examples also feature `async`hronous implementations powered by [Tokio](https://tokio.rs/).
-  These files are prefixed with `tokio02_`, `tokio1_` or `asyncstd1_`.
+  These files are prefixed with `tokio1_` or `asyncstd1_`.
 
 [basic_html.rs]: ./basic_html.rs
 [maud_html.rs]: ./maud_html.rs

examples/basic_html.rs

@@ -29,16 +29,12 @@ fn main() {
             MultiPart::alternative() // This is composed of two parts.
                 .singlepart(
                     SinglePart::builder()
-                        .header(header::ContentType(
-                            "text/plain; charset=utf8".parse().unwrap(),
-                        ))
+                        .header(header::ContentType::TEXT_PLAIN)
                         .body(String::from("Hello from Lettre! A mailer library for Rust")), // Every message should have a plain text fallback.
                 )
                 .singlepart(
                     SinglePart::builder()
-                        .header(header::ContentType(
-                            "text/html; charset=utf8".parse().unwrap(),
-                        ))
+                        .header(header::ContentType::TEXT_HTML)
                         .body(String::from(html)),
                 ),
         )

examples/maud_html.rs

@@ -38,16 +38,12 @@ fn main() {
             MultiPart::alternative() // This is composed of two parts.
                 .singlepart(
                     SinglePart::builder()
-                        .header(header::ContentType(
-                            "text/plain; charset=utf8".parse().unwrap(),
-                        ))
+                        .header(header::ContentType::TEXT_PLAIN)
                         .body(String::from("Hello from Lettre! A mailer library for Rust")), // Every message should have a plain text fallback.
                 )
                 .singlepart(
                     SinglePart::builder()
-                        .header(header::ContentType(
-                            "text/html; charset=utf8".parse().unwrap(),
-                        ))
+                        .header(header::ContentType::TEXT_HTML)
                         .body(html.into_string()),
                 ),
         )

examples/tokio02_smtp_starttls.rs

@@ -1,37 +0,0 @@
-// This line is only to make it compile from lettre's examples folder,
-// since it uses Rust 2018 crate renaming to import tokio.
-// Won't be needed in user's code.
-use tokio02_crate as tokio;
-
-use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncTransport, Message,
-    Tokio02Executor,
-};
-
-#[tokio::main]
-async fn main() {
-    tracing_subscriber::fmt::init();
-
-    let email = Message::builder()
-        .from("NoBody <nobody@domain.tld>".parse().unwrap())
-        .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-        .to("Hei <hei@domain.tld>".parse().unwrap())
-        .subject("Happy new async year")
-        .body(String::from("Be happy with async!"))
-        .unwrap();
-
-    let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
-
-    // Open a remote connection to gmail using STARTTLS
-    let mailer: AsyncSmtpTransport<Tokio02Executor> =
-        AsyncSmtpTransport::<Tokio02Executor>::starttls_relay("smtp.gmail.com")
-            .unwrap()
-            .credentials(creds)
-            .build();
-
-    // Send the email
-    match mailer.send(email).await {
-        Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
-    }
-}

examples/tokio02_smtp_tls.rs

@@ -1,37 +0,0 @@
-// This line is only to make it compile from lettre's examples folder,
-// since it uses Rust 2018 crate renaming to import tokio.
-// Won't be needed in user's code.
-use tokio02_crate as tokio;
-
-use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncTransport, Message,
-    Tokio02Executor,
-};
-
-#[tokio::main]
-async fn main() {
-    tracing_subscriber::fmt::init();
-
-    let email = Message::builder()
-        .from("NoBody <nobody@domain.tld>".parse().unwrap())
-        .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-        .to("Hei <hei@domain.tld>".parse().unwrap())
-        .subject("Happy new async year")
-        .body(String::from("Be happy with async!"))
-        .unwrap();
-
-    let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
-
-    // Open a remote connection to gmail
-    let mailer: AsyncSmtpTransport<Tokio02Executor> =
-        AsyncSmtpTransport::<Tokio02Executor>::relay("smtp.gmail.com")
-            .unwrap()
-            .credentials(creds)
-            .build();
-
-    // Send the email
-    match mailer.send(email).await {
-        Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
-    }
-}

src/address/envelope.rs

@@ -112,15 +112,16 @@ impl TryFrom<&Headers> for Envelope {
     fn try_from(headers: &Headers) -> Result<Self, Self::Error> {
         let from = match headers.get::<header::Sender>() {
             // If there is a Sender, use it
-            Some(header::Sender(a)) => Some(a.email.clone()),
+            Some(sender) => Some(Mailbox::from(sender).email),
             // ... else try From
             None => match headers.get::<header::From>() {
                 Some(header::From(a)) => {
-                    let from: Vec<Mailbox> = a.clone().into();
+                    let mut from: Vec<Mailbox> = a.into();
                     if from.len() > 1 {
                         return Err(Error::TooManyFrom);
                     }
-                    Some(from[0].email.clone())
+                    let from = from.pop().expect("From header has 1 Mailbox");
+                    Some(from.email)
                 }
                 None => None,
             },
@@ -128,18 +129,16 @@ impl TryFrom<&Headers> for Envelope {
 
         fn add_addresses_from_mailboxes(
             addresses: &mut Vec<Address>,
-            mailboxes: Option<&Mailboxes>,
+            mailboxes: Option<Mailboxes>,
         ) {
             if let Some(mailboxes) = mailboxes {
-                for mailbox in mailboxes.iter() {
-                    addresses.push(mailbox.email.clone());
-                }
+                addresses.extend(mailboxes.into_iter().map(|mb| mb.email));
             }
         }
         let mut to = vec![];
-        add_addresses_from_mailboxes(&mut to, headers.get::<header::To>().map(|h| &h.0));
-        add_addresses_from_mailboxes(&mut to, headers.get::<header::Cc>().map(|h| &h.0));
-        add_addresses_from_mailboxes(&mut to, headers.get::<header::Bcc>().map(|h| &h.0));
+        add_addresses_from_mailboxes(&mut to, headers.get::<header::To>().map(|h| h.0));
+        add_addresses_from_mailboxes(&mut to, headers.get::<header::Cc>().map(|h| h.0));
+        add_addresses_from_mailboxes(&mut to, headers.get::<header::Bcc>().map(|h| h.0));
 
         Self::new(from, to)
     }

src/address/types.rs

@@ -224,11 +224,14 @@ impl AsRef<OsStr> for Address {
 #[derive(Debug, PartialEq, Clone, Copy)]
 /// Errors in email addresses parsing
 pub enum AddressError {
+    /// Missing domain or user
     MissingParts,
+    /// Unbalanced angle bracket
     Unbalanced,
+    /// Invalid email user
     InvalidUser,
+    /// Invalid email domain
     InvalidDomain,
-    InvalidUtf8b,
 }
 
 impl Error for AddressError {}
@@ -240,7 +243,6 @@ impl Display for AddressError {
             AddressError::Unbalanced => f.write_str("Unbalanced angle bracket"),
             AddressError::InvalidUser => f.write_str("Invalid email user"),
             AddressError::InvalidDomain => f.write_str("Invalid email domain"),
-            AddressError::InvalidUtf8b => f.write_str("Invalid UTF8b data"),
         }
     }
 }

src/executor.rs

@@ -8,22 +8,22 @@ use std::path::Path;
 
 #[cfg(all(
     feature = "smtp-transport",
-    any(feature = "tokio02", feature = "tokio1", feature = "async-std1")
+    any(feature = "tokio1", feature = "async-std1")
 ))]
 use crate::transport::smtp::client::AsyncSmtpConnection;
 #[cfg(all(
     feature = "smtp-transport",
-    any(feature = "tokio02", feature = "tokio1", feature = "async-std1")
+    any(feature = "tokio1", feature = "async-std1")
 ))]
 use crate::transport::smtp::client::Tls;
 #[cfg(all(
     feature = "smtp-transport",
-    any(feature = "tokio02", feature = "tokio1", feature = "async-std1")
+    any(feature = "tokio1", feature = "async-std1")
 ))]
 use crate::transport::smtp::extension::ClientId;
 #[cfg(all(
     feature = "smtp-transport",
-    any(feature = "tokio02", feature = "tokio1", feature = "async-std1")
+    any(feature = "tokio1", feature = "async-std1")
 ))]
 use crate::transport::smtp::Error;
 
@@ -35,10 +35,7 @@ use crate::transport::smtp::Error;
 /// [`AsyncSmtpTransport`]: crate::AsyncSmtpTransport
 /// [`AsyncSendmailTransport`]: crate::AsyncSendmailTransport
 /// [`AsyncFileTransport`]: crate::AsyncFileTransport
-#[cfg_attr(
-    docsrs,
-    doc(cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1")))
-)]
+#[cfg_attr(docsrs, doc(cfg(any(feature = "tokio1", feature = "async-std1"))))]
 #[async_trait]
 pub trait Executor: Debug + Send + Sync + private::Sealed {
     #[doc(hidden)]
@@ -59,72 +56,6 @@ pub trait Executor: Debug + Send + Sync + private::Sealed {
     async fn fs_write(path: &Path, contents: &[u8]) -> IoResult<()>;
 }
 
-/// Async [`Executor`] using `tokio` `0.2.x`
-///
-/// Used by [`AsyncSmtpTransport`], [`AsyncSendmailTransport`] and [`AsyncFileTransport`]
-/// in order to be able to work with different async runtimes.
-///
-/// [`AsyncSmtpTransport`]: crate::AsyncSmtpTransport
-/// [`AsyncSendmailTransport`]: crate::AsyncSendmailTransport
-/// [`AsyncFileTransport`]: crate::AsyncFileTransport
-#[allow(missing_copy_implementations)]
-#[non_exhaustive]
-#[cfg(feature = "tokio02")]
-#[cfg_attr(docsrs, doc(cfg(feature = "tokio02")))]
-#[derive(Debug)]
-pub struct Tokio02Executor;
-
-#[async_trait]
-#[cfg(feature = "tokio02")]
-impl Executor for Tokio02Executor {
-    #[doc(hidden)]
-    #[cfg(feature = "smtp-transport")]
-    async fn connect(
-        hostname: &str,
-        port: u16,
-        hello_name: &ClientId,
-        tls: &Tls,
-    ) -> Result<AsyncSmtpConnection, Error> {
-        #[allow(clippy::match_single_binding)]
-        let tls_parameters = match tls {
-            #[cfg(any(feature = "tokio02-native-tls", feature = "tokio02-rustls-tls"))]
-            Tls::Wrapper(ref tls_parameters) => Some(tls_parameters.clone()),
-            _ => None,
-        };
-        #[allow(unused_mut)]
-        let mut conn =
-            AsyncSmtpConnection::connect_tokio02(hostname, port, hello_name, tls_parameters)
-                .await?;
-
-        #[cfg(any(feature = "tokio02-native-tls", feature = "tokio02-rustls-tls"))]
-        match tls {
-            Tls::Opportunistic(ref tls_parameters) => {
-                if conn.can_starttls() {
-                    conn.starttls(tls_parameters.clone(), hello_name).await?;
-                }
-            }
-            Tls::Required(ref tls_parameters) => {
-                conn.starttls(tls_parameters.clone(), hello_name).await?;
-            }
-            _ => (),
-        }
-
-        Ok(conn)
-    }
-
-    #[doc(hidden)]
-    #[cfg(feature = "file-transport-envelope")]
-    async fn fs_read(path: &Path) -> IoResult<Vec<u8>> {
-        tokio02_crate::fs::read(path).await
-    }
-
-    #[doc(hidden)]
-    #[cfg(feature = "file-transport")]
-    async fn fs_write(path: &Path, contents: &[u8]) -> IoResult<()> {
-        tokio02_crate::fs::write(path, contents).await
-    }
-}
-
 /// Async [`Executor`] using `tokio` `1.x`
 ///
 /// Used by [`AsyncSmtpTransport`], [`AsyncSendmailTransport`] and [`AsyncFileTransport`]
@@ -261,9 +192,6 @@ mod private {
 
     pub trait Sealed {}
 
-    #[cfg(feature = "tokio02")]
-    impl Sealed for Tokio02Executor {}
-
     #[cfg(feature = "tokio1")]
     impl Sealed for Tokio1Executor {}
 

src/lib.rs

@@ -6,7 +6,7 @@
 //! * Secure defaults
 //! * Async support
 //!
-//! Lettre requires Rust 1.45 or newer.
+//! Lettre requires Rust 1.46 or newer.
 //!
 //! ## Features
 //!
@@ -37,7 +37,6 @@
 //! Uses schannel on Windows, Security-Framework on macOS, and OpenSSL on Linux.
 //!
 //! * **native-tls** 📫: TLS support for the synchronous version of the API
-//! * **tokio02-native-tls**: TLS support for the `tokio02` async version of the API
 //! * **tokio1-native-tls**: TLS support for the `tokio1` async version of the API
 //!
 //! NOTE: native-tls isn't supported with `async-std`
@@ -49,7 +48,6 @@
 //! Rustls uses [ring] as the cryptography implementation. As a result, [not all Rust's targets are supported][ring-support].
 //!
 //! * **rustls-tls**: TLS support for the synchronous version of the API
-//! * **tokio02-rustls-tls**: TLS support for the `tokio02` async version of the API
 //! * **tokio1-rustls-tls**: TLS support for the `tokio1` async version of the API
 //! * **async-std1-rustls-tls**: TLS support for the `async-std1` async version of the API
 //!
@@ -71,11 +69,10 @@
 //! _Use [tokio] or [async-std] as an async execution runtime for sending emails_
 //!
 //! The correct runtime version must be chosen in order for lettre to work correctly.
-//! For example, when sending emails from a Tokio 1.3.0 context, the Tokio 1.x executor
+//! For example, when sending emails from a Tokio 1.x context, the Tokio 1.x executor
 //! ([`Tokio1Executor`]) must be used. Using a different version (for example Tokio 0.2.x),
 //! or async-std, would result in a runtime panic.
 //!
-//! * **tokio02**: Allow to asynchronously send emails using [Tokio 0.2.x]
 //! * **tokio1**: Allow to asynchronously send emails using [Tokio 1.x]
 //! * **async-std1**: Allow to asynchronously send emails using [async-std 1.x]
 //!
@@ -95,11 +92,10 @@
 //! [async-std]: https://docs.rs/async-std/1
 //! [ring]: https://github.com/briansmith/ring#ring
 //! [ring-support]: https://github.com/briansmith/ring#online-automated-testing
-//! [Tokio 0.2.x]: https://docs.rs/tokio/0.2
 //! [Tokio 1.x]: https://docs.rs/tokio/1
 //! [async-std 1.x]: https://docs.rs/async-std/1
 
-#![doc(html_root_url = "https://docs.rs/crate/lettre/0.10.0-beta.3")]
+#![doc(html_root_url = "https://docs.rs/crate/lettre/0.10.0-rc.1")]
 #![doc(html_favicon_url = "https://lettre.rs/favicon.ico")]
 #![doc(html_logo_url = "https://avatars0.githubusercontent.com/u/15113230?v=4")]
 #![forbid(unsafe_code)]
@@ -115,26 +111,20 @@
 
 pub mod address;
 pub mod error;
-#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
+#[cfg(any(feature = "tokio1", feature = "async-std1"))]
 mod executor;
 #[cfg(feature = "builder")]
 #[cfg_attr(docsrs, doc(cfg(feature = "builder")))]
 pub mod message;
 pub mod transport;
 
-#[cfg(feature = "builder")]
-#[macro_use]
-extern crate hyperx;
-
 #[cfg(feature = "async-std1")]
 pub use self::executor::AsyncStd1Executor;
-#[cfg(all(any(feature = "tokio02", feature = "tokio1", feature = "async-std1")))]
+#[cfg(all(any(feature = "tokio1", feature = "async-std1")))]
 pub use self::executor::Executor;
-#[cfg(feature = "tokio02")]
-pub use self::executor::Tokio02Executor;
 #[cfg(feature = "tokio1")]
 pub use self::executor::Tokio1Executor;
-#[cfg(all(any(feature = "tokio02", feature = "tokio1", feature = "async-std1")))]
+#[cfg(all(any(feature = "tokio1", feature = "async-std1")))]
 #[doc(inline)]
 pub use self::transport::AsyncTransport;
 pub use crate::address::Address;
@@ -143,7 +133,7 @@ pub use crate::address::Address;
 pub use crate::message::Message;
 #[cfg(all(
     feature = "file-transport",
-    any(feature = "tokio02", feature = "tokio1", feature = "async-std1")
+    any(feature = "tokio1", feature = "async-std1")
 ))]
 #[doc(inline)]
 pub use crate::transport::file::AsyncFileTransport;
@@ -152,7 +142,7 @@ pub use crate::transport::file::AsyncFileTransport;
 pub use crate::transport::file::FileTransport;
 #[cfg(all(
     feature = "sendmail-transport",
-    any(feature = "tokio02", feature = "tokio1", feature = "async-std1")
+    any(feature = "tokio1", feature = "async-std1")
 ))]
 #[doc(inline)]
 pub use crate::transport::sendmail::AsyncSendmailTransport;
@@ -161,7 +151,7 @@ pub use crate::transport::sendmail::AsyncSendmailTransport;
 pub use crate::transport::sendmail::SendmailTransport;
 #[cfg(all(
     feature = "smtp-transport",
-    any(feature = "tokio02", feature = "tokio1", feature = "async-std1")
+    any(feature = "tokio1", feature = "async-std1")
 ))]
 pub use crate::transport::smtp::AsyncSmtpTransport;
 #[doc(inline)]
@@ -177,11 +167,11 @@ pub(crate) type BoxError = Box<dyn StdError + Send + Sync>;
 #[cfg(test)]
 #[cfg(feature = "builder")]
 mod test {
-    use super::*;
-    use crate::message::{header, Mailbox, Mailboxes};
-    use hyperx::header::Headers;
     use std::convert::TryFrom;
 
+    use super::*;
+    use crate::message::{header, header::Headers, Mailbox, Mailboxes};
+
     #[test]
     fn envelope_from_headers() {
         let from = Mailboxes::new().with("kayo@example.com".parse().unwrap());
@@ -208,9 +198,9 @@ mod test {
         let to = Mailboxes::new().with("amousset@example.com".parse().unwrap());
 
         let mut headers = Headers::new();
-        headers.set(header::From(from));
-        headers.set(header::Sender(sender));
-        headers.set(header::To(to));
+        headers.set(header::From::from(from));
+        headers.set(header::Sender::from(sender));
+        headers.set(header::To::from(to));
 
         assert_eq!(
             Envelope::try_from(&headers).unwrap(),
@@ -228,8 +218,8 @@ mod test {
         let sender = Mailbox::new(None, "kayo2@example.com".parse().unwrap());
 
         let mut headers = Headers::new();
-        headers.set(header::From(from));
-        headers.set(header::Sender(sender));
+        headers.set(header::From::from(from));
+        headers.set(header::Sender::from(sender));
 
         assert!(Envelope::try_from(&headers).is_err(),);
     }

src/message/attachment.rs

@@ -0,0 +1,91 @@
+use crate::message::{
+    header::{self, ContentType},
+    IntoBody, SinglePart,
+};
+
+/// `SinglePart` builder for attachments
+///
+/// Allows building attachment parts easily.
+#[derive(Clone)]
+pub struct Attachment {
+    disposition: Disposition,
+}
+
+#[derive(Clone)]
+enum Disposition {
+    /// file name
+    Attached(String),
+    /// content id
+    Inline(String),
+}
+
+impl Attachment {
+    /// Creates a new attachment
+    pub fn new(filename: String) -> Self {
+        Attachment {
+            disposition: Disposition::Attached(filename),
+        }
+    }
+
+    /// Creates a new inline attachment
+    pub fn new_inline(content_id: String) -> Self {
+        Attachment {
+            disposition: Disposition::Inline(content_id),
+        }
+    }
+
+    /// Build the attachment part
+    pub fn body<T: IntoBody>(self, content: T, content_type: ContentType) -> SinglePart {
+        let mut builder = SinglePart::builder();
+        builder = match self.disposition {
+            Disposition::Attached(filename) => {
+                builder.header(header::ContentDisposition::attachment(&filename))
+            }
+            Disposition::Inline(content_id) => builder
+                .header(header::ContentId::from(format!("<{}>", content_id)))
+                .header(header::ContentDisposition::inline()),
+        };
+        builder = builder.header(content_type);
+        builder.body(content)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::message::header::ContentType;
+
+    #[test]
+    fn attachment() {
+        let part = super::Attachment::new(String::from("test.txt")).body(
+            String::from("Hello world!"),
+            ContentType::parse("text/plain").unwrap(),
+        );
+        assert_eq!(
+            &String::from_utf8_lossy(&part.formatted()),
+            concat!(
+                "Content-Disposition: attachment; filename=\"test.txt\"\r\n",
+                "Content-Type: text/plain\r\n",
+                "Content-Transfer-Encoding: 7bit\r\n\r\n",
+                "Hello world!\r\n",
+            )
+        );
+    }
+
+    #[test]
+    fn attachment_inline() {
+        let part = super::Attachment::new_inline(String::from("id")).body(
+            String::from("Hello world!"),
+            ContentType::parse("text/plain").unwrap(),
+        );
+        assert_eq!(
+            &String::from_utf8_lossy(&part.formatted()),
+            concat!(
+                "Content-ID: <id>\r\n",
+                "Content-Disposition: inline\r\n",
+                "Content-Type: text/plain\r\n",
+                "Content-Transfer-Encoding: 7bit\r\n\r\n",
+                "Hello world!\r\n"
+            )
+        );
+    }
+}

src/message/body.rs

@@ -1,5 +1,6 @@
 use std::{
     io::{self, Write},
+    mem,
     ops::Deref,
 };
 
@@ -18,7 +19,9 @@ pub struct Body {
 /// makes for a more efficient `Content-Transfer-Encoding` to be chosen.
 #[derive(Debug, Clone)]
 pub enum MaybeString {
+    /// Binary data
     Binary(Vec<u8>),
+    /// UTF-8 string
     String(String),
 }
 
@@ -30,13 +33,16 @@ impl Body {
     /// Automatically chooses the most efficient encoding between
     /// `7bit`, `quoted-printable` and `base64`.
     ///
+    /// If `String` is passed, line endings are converted to `CRLF`.
+    ///
     /// If `buf` is valid utf-8 a `String` should be supplied, as `String`s
     /// can be encoded as `7bit` or `quoted-printable`, while `Vec<u8>` always
     /// get encoded as `base64`.
     pub fn new<B: Into<MaybeString>>(buf: B) -> Self {
-        let buf: MaybeString = buf.into();
+        let mut buf: MaybeString = buf.into();
 
         let encoding = buf.encoding();
+        buf.encode_crlf();
         Self::new_impl(buf.into(), encoding)
     }
 
@@ -44,6 +50,8 @@ impl Body {
     ///
     /// [`Body::new`] is generally the better option.
     ///
+    /// If `String` is passed, line endings are converted to `CRLF`.
+    ///
     /// Returns an [`Err`] giving back the supplied `buf`, in case the chosen
     /// encoding would have resulted into `buf` being encoded
     /// into an invalid body.
@@ -51,12 +59,13 @@ impl Body {
         buf: B,
         encoding: ContentTransferEncoding,
     ) -> Result<Self, Vec<u8>> {
-        let buf: MaybeString = buf.into();
+        let mut buf: MaybeString = buf.into();
 
         if !buf.is_encoding_ok(encoding) {
             return Err(buf.into());
         }
 
+        buf.encode_crlf();
         Ok(Self::new_impl(buf.into(), encoding))
     }
 
@@ -162,6 +171,14 @@ impl MaybeString {
         }
     }
 
+    /// Encode line endings to CRLF if the variant is `String`
+    fn encode_crlf(&mut self) {
+        match self {
+            Self::String(string) => in_place_crlf_line_endings(string),
+            Self::Binary(_) => {}
+        }
+    }
+
     /// Returns `true` if using `encoding` to encode this `MaybeString`
     /// would result into an invalid encoded body.
     fn is_encoding_ok(&self, encoding: ContentTransferEncoding) -> bool {
@@ -189,6 +206,7 @@ impl MaybeString {
 /// **NOTE:** if using the specified `encoding` would result into a malformed
 /// body, this will panic!
 pub trait IntoBody {
+    /// Encode as valid body
     fn into_body(self, encoding: Option<ContentTransferEncoding>) -> Body;
 }
 
@@ -322,9 +340,44 @@ where
     }
 }
 
+/// In place conversion to CRLF line endings
+fn in_place_crlf_line_endings(string: &mut String) {
+    let indices = find_all_lf_char_indices(&string);
+
+    for i in indices {
+        // this relies on `indices` being in reverse order
+        string.insert(i, '\r');
+    }
+}
+
+/// Find indices to all places where `\r` should be inserted
+/// in order to make `s` have CRLF line endings
+///
+/// The list is reversed, which is more efficient.
+fn find_all_lf_char_indices(s: &str) -> Vec<usize> {
+    let mut indices = Vec::new();
+
+    let mut found_lf = false;
+    for (i, c) in s.char_indices().rev() {
+        if mem::take(&mut found_lf) && c != '\r' {
+            // the previous character was `\n`, but this isn't a `\r`
+            indices.push(i + c.len_utf8());
+        }
+
+        found_lf = c == '\n';
+    }
+
+    if found_lf {
+        // the first character is `\n`
+        indices.push(0);
+    }
+
+    indices
+}
+
 #[cfg(test)]
 mod test {
-    use super::{Body, ContentTransferEncoding};
+    use super::{in_place_crlf_line_endings, Body, ContentTransferEncoding};
 
     #[test]
     fn seven_bit_detect() {
@@ -578,4 +631,31 @@ mod test {
             .as_bytes()
         );
     }
+
+    #[test]
+    fn crlf() {
+        let mut string = String::from("Send me a ✉️\nwith\nlettre!\n😀");
+
+        in_place_crlf_line_endings(&mut string);
+        assert_eq!(string, "Send me a ✉️\r\nwith\r\nlettre!\r\n😀");
+    }
+
+    #[test]
+    fn harsh_crlf() {
+        let mut string = String::from("\n\nSend me a ✉️\r\n\nwith\n\nlettre!\n\r\n😀");
+
+        in_place_crlf_line_endings(&mut string);
+        assert_eq!(
+            string,
+            "\r\n\r\nSend me a ✉️\r\n\r\nwith\r\n\r\nlettre!\r\n\r\n😀"
+        );
+    }
+
+    #[test]
+    fn crlf_noop() {
+        let mut string = String::from("\r\nSend me a ✉️\r\nwith\r\nlettre!\r\n😀");
+
+        in_place_crlf_line_endings(&mut string);
+        assert_eq!(string, "\r\nSend me a ✉️\r\nwith\r\nlettre!\r\n😀");
+    }
 }

src/message/header/content.rs

@@ -1,16 +1,10 @@
-use hyperx::{
-    header::{Formatter as HeaderFormatter, Header, RawLike},
-    Error as HeaderError, Result as HyperResult,
-};
 use std::{
     fmt::{Display, Formatter as FmtFormatter, Result as FmtResult},
-    str::{from_utf8, FromStr},
+    str::FromStr,
 };
 
-header! {
-    /// `Content-Id` header, defined in [RFC2045](https://tools.ietf.org/html/rfc2045#section-7)
-    (ContentId, "Content-ID") => [String]
-}
+use super::{Header, HeaderName};
+use crate::BoxError;
 
 /// `Content-Transfer-Encoding` of the body
 ///
@@ -19,17 +13,29 @@ header! {
 /// use-caches this header shouldn't be set manually.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum ContentTransferEncoding {
+    /// ASCII
     SevenBit,
+    /// Quoted-Printable encoding
     QuotedPrintable,
+    /// base64 encoding
     Base64,
-    // 8BITMIME
+    /// Requires `8BITMIME`
     EightBit,
+    /// Binary data
     Binary,
 }
 
-impl Default for ContentTransferEncoding {
-    fn default() -> Self {
-        ContentTransferEncoding::Base64
+impl Header for ContentTransferEncoding {
+    fn name() -> HeaderName {
+        HeaderName::new_from_ascii_str("Content-Transfer-Encoding")
+    }
+
+    fn parse(s: &str) -> Result<Self, BoxError> {
+        Ok(s.parse()?)
+    }
+
+    fn display(&self) -> String {
+        self.to_string()
     }
 }
 
@@ -59,35 +65,16 @@ impl FromStr for ContentTransferEncoding {
     }
 }
 
-impl Header for ContentTransferEncoding {
-    fn header_name() -> &'static str {
-        "Content-Transfer-Encoding"
-    }
-
-    // FIXME HeaderError->HeaderError, same for result
-    fn parse_header<'a, T>(raw: &'a T) -> HyperResult<Self>
-    where
-        T: RawLike<'a>,
-        Self: Sized,
-    {
-        raw.one()
-            .ok_or(HeaderError::Header)
-            .and_then(|r| from_utf8(r).map_err(|_| HeaderError::Header))
-            .and_then(|s| {
-                s.parse::<ContentTransferEncoding>()
-                    .map_err(|_| HeaderError::Header)
-            })
-    }
-
-    fn fmt_header(&self, f: &mut HeaderFormatter<'_, '_>) -> FmtResult {
-        f.fmt_line(&format!("{}", self))
+impl Default for ContentTransferEncoding {
+    fn default() -> Self {
+        ContentTransferEncoding::Base64
     }
 }
 
 #[cfg(test)]
 mod test {
     use super::ContentTransferEncoding;
-    use hyperx::header::Headers;
+    use crate::message::header::{HeaderName, Headers};
 
     #[test]
     fn format_content_transfer_encoding() {
@@ -95,35 +82,35 @@ mod test {
 
         headers.set(ContentTransferEncoding::SevenBit);
 
-        assert_eq!(
-            format!("{}", headers),
-            "Content-Transfer-Encoding: 7bit\r\n"
-        );
+        assert_eq!(headers.to_string(), "Content-Transfer-Encoding: 7bit\r\n");
 
         headers.set(ContentTransferEncoding::Base64);
 
-        assert_eq!(
-            format!("{}", headers),
-            "Content-Transfer-Encoding: base64\r\n"
-        );
+        assert_eq!(headers.to_string(), "Content-Transfer-Encoding: base64\r\n");
     }
 
     #[test]
     fn parse_content_transfer_encoding() {
         let mut headers = Headers::new();
 
-        headers.set_raw("Content-Transfer-Encoding", "7bit");
-
-        assert_eq!(
-            headers.get::<ContentTransferEncoding>(),
-            Some(&ContentTransferEncoding::SevenBit)
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("Content-Transfer-Encoding"),
+            "7bit".to_string(),
         );
 
-        headers.set_raw("Content-Transfer-Encoding", "base64");
+        assert_eq!(
+            headers.get::<ContentTransferEncoding>(),
+            Some(ContentTransferEncoding::SevenBit)
+        );
+
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("Content-Transfer-Encoding"),
+            "base64".to_string(),
+        );
 
         assert_eq!(
             headers.get::<ContentTransferEncoding>(),
-            Some(&ContentTransferEncoding::Base64)
+            Some(ContentTransferEncoding::Base64)
         );
     }
 }

src/message/header/content_disposition.rs

@@ -0,0 +1,89 @@
+use super::{Header, HeaderName};
+use crate::BoxError;
+
+/// `Content-Disposition` of an attachment
+///
+/// Defined in [RFC2183](https://tools.ietf.org/html/rfc2183)
+#[derive(Debug, Clone, PartialEq)]
+pub struct ContentDisposition(String);
+
+impl ContentDisposition {
+    /// An attachment which should be displayed inline into the message
+    pub fn inline() -> Self {
+        Self("inline".into())
+    }
+
+    /// An attachment which should be displayed inline into the message, but that also
+    /// species the filename in case it were to be downloaded
+    pub fn inline_with_name(file_name: &str) -> Self {
+        debug_assert!(!file_name.contains('"'), "file_name shouldn't contain '\"'");
+        Self(format!("inline; filename=\"{}\"", file_name))
+    }
+
+    /// An attachment which is separate from the body of the message, and can be downloaded separately
+    pub fn attachment(file_name: &str) -> Self {
+        debug_assert!(!file_name.contains('"'), "file_name shouldn't contain '\"'");
+        Self(format!("attachment; filename=\"{}\"", file_name))
+    }
+}
+
+impl Header for ContentDisposition {
+    fn name() -> HeaderName {
+        HeaderName::new_from_ascii_str("Content-Disposition")
+    }
+
+    fn parse(s: &str) -> Result<Self, BoxError> {
+        Ok(Self(s.into()))
+    }
+
+    fn display(&self) -> String {
+        self.0.clone()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::ContentDisposition;
+    use crate::message::header::{HeaderName, Headers};
+
+    #[test]
+    fn format_content_disposition() {
+        let mut headers = Headers::new();
+
+        headers.set(ContentDisposition::inline());
+
+        assert_eq!(format!("{}", headers), "Content-Disposition: inline\r\n");
+
+        headers.set(ContentDisposition::attachment("something.txt"));
+
+        assert_eq!(
+            format!("{}", headers),
+            "Content-Disposition: attachment; filename=\"something.txt\"\r\n"
+        );
+    }
+
+    #[test]
+    fn parse_content_disposition() {
+        let mut headers = Headers::new();
+
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("Content-Disposition"),
+            "inline".to_string(),
+        );
+
+        assert_eq!(
+            headers.get::<ContentDisposition>(),
+            Some(ContentDisposition::inline())
+        );
+
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("Content-Disposition"),
+            "attachment; filename=\"something.txt\"".to_string(),
+        );
+
+        assert_eq!(
+            headers.get::<ContentDisposition>(),
+            Some(ContentDisposition::attachment("something.txt"))
+        );
+    }
+}

src/message/header/content_type.rs

@@ -0,0 +1,123 @@
+use std::{
+    error::Error as StdError,
+    fmt::{self, Display},
+    str::FromStr,
+};
+
+use mime::Mime;
+
+use super::{Header, HeaderName};
+use crate::BoxError;
+
+/// `Content-Type` of the body
+///
+/// Defined in [RFC2045](https://tools.ietf.org/html/rfc2045#section-5)
+#[derive(Debug, Clone, PartialEq)]
+pub struct ContentType(Mime);
+
+impl ContentType {
+    /// A `ContentType` of type `text/plain; charset=utf-8`
+    ///
+    /// Indicates that the body is in utf-8 encoded plain text.
+    pub const TEXT_PLAIN: ContentType = Self::from_mime(mime::TEXT_PLAIN_UTF_8);
+
+    /// A `ContentType` of type `text/html; charset=utf-8`
+    ///
+    /// Indicates that the body is in utf-8 encoded html.
+    pub const TEXT_HTML: ContentType = Self::from_mime(mime::TEXT_HTML_UTF_8);
+
+    /// Parse `s` into `ContentType`
+    pub fn parse(s: &str) -> Result<ContentType, ContentTypeErr> {
+        Ok(Self::from_mime(s.parse().map_err(ContentTypeErr)?))
+    }
+
+    pub(crate) const fn from_mime(mime: Mime) -> Self {
+        Self(mime)
+    }
+
+    pub(crate) fn as_ref(&self) -> &Mime {
+        &self.0
+    }
+}
+
+impl Header for ContentType {
+    fn name() -> HeaderName {
+        HeaderName::new_from_ascii_str("Content-Type")
+    }
+
+    fn parse(s: &str) -> Result<Self, BoxError> {
+        Ok(Self(s.parse()?))
+    }
+
+    fn display(&self) -> String {
+        self.0.to_string()
+    }
+}
+
+impl FromStr for ContentType {
+    type Err = ContentTypeErr;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Self::parse(s)
+    }
+}
+
+/// An error occurred while trying to [`ContentType::parse`].
+#[derive(Debug)]
+pub struct ContentTypeErr(mime::FromStrError);
+
+impl StdError for ContentTypeErr {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        Some(&self.0)
+    }
+}
+
+impl Display for ContentTypeErr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::ContentType;
+    use crate::message::header::{HeaderName, Headers};
+
+    #[test]
+    fn format_content_type() {
+        let mut headers = Headers::new();
+
+        headers.set(ContentType::TEXT_PLAIN);
+
+        assert_eq!(
+            headers.to_string(),
+            "Content-Type: text/plain; charset=utf-8\r\n"
+        );
+
+        headers.set(ContentType::TEXT_HTML);
+
+        assert_eq!(
+            headers.to_string(),
+            "Content-Type: text/html; charset=utf-8\r\n"
+        );
+    }
+
+    #[test]
+    fn parse_content_type() {
+        let mut headers = Headers::new();
+
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("Content-Type"),
+            "text/plain; charset=utf-8".to_string(),
+        );
+
+        assert_eq!(headers.get::<ContentType>(), Some(ContentType::TEXT_PLAIN));
+
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("Content-Type"),
+            "text/html; charset=utf-8".to_string(),
+        );
+
+        assert_eq!(headers.get::<ContentType>(), Some(ContentType::TEXT_HTML));
+    }
+}

src/message/header/date.rs

@@ -0,0 +1,133 @@
+use std::time::SystemTime;
+
+use httpdate::HttpDate;
+
+use super::{Header, HeaderName};
+use crate::BoxError;
+
+/// Message `Date` header
+///
+/// Defined in [RFC2822](https://tools.ietf.org/html/rfc2822#section-3.3)
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Date(HttpDate);
+
+impl Date {
+    /// Build a `Date` from [`SystemTime`]
+    pub fn new(st: SystemTime) -> Self {
+        Self(st.into())
+    }
+
+    /// Get the current date
+    ///
+    /// Shortcut for `Date::new(SystemTime::now())`
+    pub fn now() -> Self {
+        Self::new(SystemTime::now())
+    }
+}
+
+impl Header for Date {
+    fn name() -> HeaderName {
+        HeaderName::new_from_ascii_str("Date")
+    }
+
+    fn parse(s: &str) -> Result<Self, BoxError> {
+        let mut s = String::from(s);
+        if s.ends_with(" -0000") {
+            // The httpdate crate expects the `Date` to end in ` GMT`, but email
+            // uses `-0000`, so we crudely fix this issue here.
+
+            s.truncate(s.len() - "-0000".len());
+            s.push_str("GMT");
+        }
+
+        Ok(Self(s.parse::<HttpDate>()?))
+    }
+
+    fn display(&self) -> String {
+        let mut s = self.0.to_string();
+        if s.ends_with(" GMT") {
+            // The httpdate crate always appends ` GMT` to the end of the string,
+            // but this is considered an obsolete date format for email
+            // https://tools.ietf.org/html/rfc2822#appendix-A.6.2,
+            // so we replace `GMT` with `-0000`
+            s.truncate(s.len() - "GMT".len());
+            s.push_str("-0000");
+        }
+
+        s
+    }
+}
+
+impl From<SystemTime> for Date {
+    fn from(st: SystemTime) -> Self {
+        Self::new(st)
+    }
+}
+
+impl From<Date> for SystemTime {
+    fn from(this: Date) -> SystemTime {
+        this.0.into()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::time::{Duration, SystemTime};
+
+    use super::Date;
+    use crate::message::header::{HeaderName, Headers};
+
+    #[test]
+    fn format_date() {
+        let mut headers = Headers::new();
+
+        // Tue, 15 Nov 1994 08:12:31 GMT
+        headers.set(Date::from(
+            SystemTime::UNIX_EPOCH + Duration::from_secs(784887151),
+        ));
+
+        assert_eq!(
+            headers.to_string(),
+            "Date: Tue, 15 Nov 1994 08:12:31 -0000\r\n".to_string()
+        );
+
+        // Tue, 15 Nov 1994 08:12:32 GMT
+        headers.set(Date::from(
+            SystemTime::UNIX_EPOCH + Duration::from_secs(784887152),
+        ));
+
+        assert_eq!(
+            headers.to_string(),
+            "Date: Tue, 15 Nov 1994 08:12:32 -0000\r\n"
+        );
+    }
+
+    #[test]
+    fn parse_date() {
+        let mut headers = Headers::new();
+
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("Date"),
+            "Tue, 15 Nov 1994 08:12:31 -0000".to_string(),
+        );
+
+        assert_eq!(
+            headers.get::<Date>(),
+            Some(Date::from(
+                SystemTime::UNIX_EPOCH + Duration::from_secs(784887151),
+            ))
+        );
+
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("Date"),
+            "Tue, 15 Nov 1994 08:12:32 -0000".to_string(),
+        );
+
+        assert_eq!(
+            headers.get::<Date>(),
+            Some(Date::from(
+                SystemTime::UNIX_EPOCH + Duration::from_secs(784887152),
+            ))
+        );
+    }
+}

src/message/header/mailbox.rs

@@ -1,12 +1,8 @@
-use crate::message::{
-    mailbox::{Mailbox, Mailboxes},
-    utf8_b,
+use super::{Header, HeaderName};
+use crate::{
+    message::mailbox::{Mailbox, Mailboxes},
+    BoxError,
 };
-use hyperx::{
-    header::{Formatter as HeaderFormatter, Header, RawLike},
-    Error as HeaderError, Result as HyperResult,
-};
-use std::{fmt::Result as FmtResult, slice::Iter, str::from_utf8};
 
 /// Header which can contains multiple mailboxes
 pub trait MailboxesHeader {
@@ -17,26 +13,34 @@ macro_rules! mailbox_header {
     ($(#[$doc:meta])*($type_name: ident, $header_name: expr)) => {
         $(#[$doc])*
         #[derive(Debug, Clone, PartialEq)]
-        pub struct $type_name(pub Mailbox);
+        pub struct $type_name(Mailbox);
 
         impl Header for $type_name {
-            fn header_name() -> &'static str {
-                $header_name
+            fn name() -> HeaderName {
+                HeaderName::new_from_ascii_str($header_name)
             }
 
-            fn parse_header<'a, T>(raw: &'a T) -> HyperResult<Self> where
-    T: RawLike<'a>,
-    Self: Sized {
-                raw.one()
-                    .ok_or(HeaderError::Header)
-                    .and_then(parse_mailboxes)
-                    .and_then(|mbs| {
-                        mbs.into_single().ok_or(HeaderError::Header)
-                    }).map($type_name)
+            fn parse(s: &str) -> Result<Self, BoxError> {
+                let mailbox: Mailbox = s.parse()?;
+                Ok(Self(mailbox))
             }
 
-            fn fmt_header(&self, f: &mut HeaderFormatter<'_, '_>) -> FmtResult {
-                f.fmt_line(&self.0.recode_name(utf8_b::encode))
+            fn display(&self) -> String {
+                self.0.to_string()
+            }
+        }
+
+        impl std::convert::From<Mailbox> for $type_name {
+            #[inline]
+            fn from(mailbox: Mailbox) -> Self {
+                Self(mailbox)
+            }
+        }
+
+        impl std::convert::From<$type_name> for Mailbox {
+            #[inline]
+            fn from(this: $type_name) -> Mailbox {
+                this.0
             }
         }
     };
@@ -46,7 +50,7 @@ macro_rules! mailboxes_header {
     ($(#[$doc:meta])*($type_name: ident, $header_name: expr)) => {
         $(#[$doc])*
         #[derive(Debug, Clone, PartialEq)]
-        pub struct $type_name(pub Mailboxes);
+        pub struct $type_name(pub(crate) Mailboxes);
 
         impl MailboxesHeader for $type_name {
             fn join_mailboxes(&mut self, other: Self) {
@@ -55,23 +59,31 @@ macro_rules! mailboxes_header {
         }
 
         impl Header for $type_name {
-            fn header_name() -> &'static str {
-                $header_name
+            fn name() -> HeaderName {
+                HeaderName::new_from_ascii_str($header_name)
             }
 
-            fn parse_header<'a, T>(raw: &'a T) -> HyperResult<$type_name>
-            where
-                T: RawLike<'a>,
-                Self: Sized,
-            {
-                raw.one()
-                    .ok_or(HeaderError::Header)
-                    .and_then(parse_mailboxes)
-                    .map($type_name)
+            fn parse(s: &str) -> Result<Self, BoxError> {
+                let mailbox: Mailboxes = s.parse()?;
+                Ok(Self(mailbox))
             }
 
-            fn fmt_header(&self, f: &mut HeaderFormatter<'_, '_>) -> FmtResult {
-                format_mailboxes(self.0.iter(), f)
+            fn display(&self) -> String {
+                self.0.to_string()
+            }
+        }
+
+        impl std::convert::From<Mailboxes> for $type_name {
+            #[inline]
+            fn from(mailboxes: Mailboxes) -> Self {
+                Self(mailboxes)
+            }
+        }
+
+        impl std::convert::From<$type_name> for Mailboxes {
+            #[inline]
+            fn from(this: $type_name) -> Mailboxes {
+                this.0
             }
         }
     };
@@ -146,26 +158,10 @@ mailboxes_header! {
     (Bcc, "Bcc")
 }
 
-fn parse_mailboxes(raw: &[u8]) -> HyperResult<Mailboxes> {
-    if let Ok(src) = from_utf8(raw) {
-        if let Ok(mbs) = src.parse() {
-            return Ok(mbs);
-        }
-    }
-    Err(HeaderError::Header)
-}
-
-fn format_mailboxes<'a>(mbs: Iter<'a, Mailbox>, f: &mut HeaderFormatter<'_, '_>) -> FmtResult {
-    f.fmt_line(&Mailboxes::from(
-        mbs.map(|mb| mb.recode_name(utf8_b::encode))
-            .collect::<Vec<_>>(),
-    ))
-}
-
 #[cfg(test)]
 mod test {
     use super::{From, Mailbox, Mailboxes};
-    use hyperx::header::Headers;
+    use crate::message::header::{HeaderName, Headers};
 
     #[test]
     fn format_single_without_name() {
@@ -174,7 +170,7 @@ mod test {
         let mut headers = Headers::new();
         headers.set(From(from));
 
-        assert_eq!(format!("{}", headers), "From: kayo@example.com\r\n");
+        assert_eq!(headers.to_string(), "From: kayo@example.com\r\n");
     }
 
     #[test]
@@ -184,7 +180,7 @@ mod test {
         let mut headers = Headers::new();
         headers.set(From(from));
 
-        assert_eq!(format!("{}", headers), "From: K. <kayo@example.com>\r\n");
+        assert_eq!(headers.to_string(), "From: K. <kayo@example.com>\r\n");
     }
 
     #[test]
@@ -197,7 +193,7 @@ mod test {
         headers.set(From(from));
 
         assert_eq!(
-            format!("{}", headers),
+            headers.to_string(),
             "From: kayo@example.com, pony@domain.tld\r\n"
         );
     }
@@ -213,7 +209,7 @@ mod test {
         headers.set(From(from.into()));
 
         assert_eq!(
-            format!("{}", headers),
+            headers.to_string(),
             "From: K. <kayo@example.com>, Pony P. <pony@domain.tld>\r\n"
         );
     }
@@ -226,7 +222,7 @@ mod test {
         headers.set(From(from.into()));
 
         assert_eq!(
-            format!("{}", headers),
+            headers.to_string(),
             "From: =?utf-8?b?0JrQsNC50L4=?= <kayo@example.com>\r\n"
         );
     }
@@ -236,9 +232,12 @@ mod test {
         let from = vec!["kayo@example.com".parse().unwrap()].into();
 
         let mut headers = Headers::new();
-        headers.set_raw("From", "kayo@example.com");
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("From"),
+            "kayo@example.com".to_string(),
+        );
 
-        assert_eq!(headers.get::<From>(), Some(&From(from)));
+        assert_eq!(headers.get::<From>(), Some(From(from)));
     }
 
     #[test]
@@ -246,9 +245,12 @@ mod test {
         let from = vec!["K. <kayo@example.com>".parse().unwrap()].into();
 
         let mut headers = Headers::new();
-        headers.set_raw("From", "K. <kayo@example.com>");
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("From"),
+            "K. <kayo@example.com>".to_string(),
+        );
 
-        assert_eq!(headers.get::<From>(), Some(&From(from)));
+        assert_eq!(headers.get::<From>(), Some(From(from)));
     }
 
     #[test]
@@ -259,9 +261,12 @@ mod test {
         ];
 
         let mut headers = Headers::new();
-        headers.set_raw("From", "kayo@example.com, pony@domain.tld");
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("From"),
+            "kayo@example.com, pony@domain.tld".to_string(),
+        );
 
-        assert_eq!(headers.get::<From>(), Some(&From(from.into())));
+        assert_eq!(headers.get::<From>(), Some(From(from.into())));
     }
 
     #[test]
@@ -272,18 +277,11 @@ mod test {
         ];
 
         let mut headers = Headers::new();
-        headers.set_raw("From", "K. <kayo@example.com>, Pony P. <pony@domain.tld>");
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("From"),
+            "K. <kayo@example.com>, Pony P. <pony@domain.tld>".to_string(),
+        );
 
-        assert_eq!(headers.get::<From>(), Some(&From(from.into())));
-    }
-
-    #[test]
-    fn parse_single_with_utf8_name() {
-        let from: Vec<Mailbox> = vec!["Кайо <kayo@example.com>".parse().unwrap()];
-
-        let mut headers = Headers::new();
-        headers.set_raw("From", "=?utf-8?b?0JrQsNC50L4=?= <kayo@example.com>");
-
-        assert_eq!(headers.get::<From>(), Some(&From(from.into())));
+        assert_eq!(headers.get::<From>(), Some(From(from.into())));
     }
 }

src/message/header/mod.rs

@@ -1,13 +1,800 @@
 //! Headers widely used in email messages
 
+use std::{
+    borrow::Cow,
+    error::Error,
+    fmt::{self, Display, Formatter},
+    ops::Deref,
+};
+
+pub use self::{
+    content::*,
+    content_disposition::ContentDisposition,
+    content_type::{ContentType, ContentTypeErr},
+    date::Date,
+    mailbox::*,
+    special::*,
+    textual::*,
+};
+use crate::BoxError;
+
 mod content;
+mod content_disposition;
+mod content_type;
+mod date;
 mod mailbox;
 mod special;
 mod textual;
 
-pub use self::{content::*, mailbox::*, special::*, textual::*};
+pub trait Header: Clone {
+    fn name() -> HeaderName;
 
-pub use hyperx::header::{
-    Charset, ContentDisposition, ContentLocation, ContentType, Date, DispositionParam,
-    DispositionType, Header, Headers, HttpDate as EmailDate,
-};
+    fn parse(s: &str) -> Result<Self, BoxError>;
+
+    fn display(&self) -> String;
+}
+
+/// A set of email headers
+#[derive(Debug, Clone, Default)]
+pub struct Headers {
+    headers: Vec<(HeaderName, String)>,
+}
+
+impl Headers {
+    /// Create an empty `Headers`
+    ///
+    /// This function does not allocate.
+    #[inline]
+    pub const fn new() -> Self {
+        Self {
+            headers: Vec::new(),
+        }
+    }
+
+    /// Create an empty `Headers` with a pre-allocated capacity
+    ///
+    /// Pre-allocates a capacity of at least `capacity`.
+    #[inline]
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self {
+            headers: Vec::with_capacity(capacity),
+        }
+    }
+
+    /// Returns a copy of an `Header` present in `Headers`
+    ///
+    /// Returns `None` if `Header` isn't present in `Headers`.
+    pub fn get<H: Header>(&self) -> Option<H> {
+        self.get_raw(&H::name()).and_then(|raw| H::parse(raw).ok())
+    }
+
+    /// Sets `Header` into `Headers`, overriding `Header` if it
+    /// was already present in `Headers`
+    pub fn set<H: Header>(&mut self, header: H) {
+        self.insert_raw(H::name(), header.display());
+    }
+
+    /// Remove `Header` from `Headers`, returning it
+    ///
+    /// Returns `None` if `Header` isn't in `Headers`.
+    pub fn remove<H: Header>(&mut self) -> Option<H> {
+        self.remove_raw(&H::name())
+            .and_then(|(_name, raw)| H::parse(&raw).ok())
+    }
+
+    /// Clears `Headers`, removing all headers from it
+    ///
+    /// Any pre-allocated capacity is left untouched.
+    #[inline]
+    pub fn clear(&mut self) {
+        self.headers.clear();
+    }
+
+    /// Returns a reference to the raw value of header `name`
+    ///
+    /// Returns `None` if `name` isn't present in `Headers`.
+    pub fn get_raw(&self, name: &str) -> Option<&str> {
+        self.find_header(name).map(|(_name, value)| value)
+    }
+
+    /// Inserts a raw header into `Headers`, overriding `value` if it
+    /// was already present in `Headers`.
+    pub fn insert_raw(&mut self, name: HeaderName, value: String) {
+        match self.find_header_mut(&name) {
+            Some((_, current_value)) => {
+                *current_value = value;
+            }
+            None => {
+                self.headers.push((name, value));
+            }
+        }
+    }
+
+    /// Appends a raw header into `Headers`
+    ///
+    /// If a header with a name of `name` is already present,
+    /// appends `, ` + `value` to it's current value.
+    pub fn append_raw(&mut self, name: HeaderName, value: String) {
+        match self.find_header_mut(&name) {
+            Some((_name, prev_value)) => {
+                prev_value.push_str(", ");
+                prev_value.push_str(&value);
+            }
+            None => self.headers.push((name, value)),
+        }
+    }
+
+    /// Remove a raw header from `Headers`, returning it
+    ///
+    /// Returns `None` if `name` isn't present in `Headers`.
+    pub fn remove_raw(&mut self, name: &str) -> Option<(HeaderName, String)> {
+        self.find_header_index(name).map(|i| self.headers.remove(i))
+    }
+
+    fn find_header(&self, name: &str) -> Option<(&HeaderName, &str)> {
+        self.headers
+            .iter()
+            .find(|&(name_, _value)| name.eq_ignore_ascii_case(name_))
+            .map(|t| (&t.0, t.1.as_str()))
+    }
+
+    fn find_header_mut(&mut self, name: &str) -> Option<(&HeaderName, &mut String)> {
+        self.headers
+            .iter_mut()
+            .find(|(name_, _value)| name.eq_ignore_ascii_case(name_))
+            .map(|t| (&t.0, &mut t.1))
+    }
+
+    fn find_header_index(&self, name: &str) -> Option<usize> {
+        self.headers
+            .iter()
+            .enumerate()
+            .find(|&(_i, (name_, _value))| name.eq_ignore_ascii_case(name_))
+            .map(|(i, _)| i)
+    }
+}
+
+impl Display for Headers {
+    /// Formats `Headers`, ready to put them into an email
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        for (name, value) in &self.headers {
+            Display::fmt(name, f)?;
+            f.write_str(": ")?;
+            HeaderValueEncoder::encode(&name, &value, f)?;
+            f.write_str("\r\n")?;
+        }
+
+        Ok(())
+    }
+}
+
+/// A possible error when converting a `HeaderName` from another type.
+// comes from `http` crate
+#[allow(missing_copy_implementations)]
+#[derive(Clone)]
+pub struct InvalidHeaderName {
+    _priv: (),
+}
+
+impl fmt::Debug for InvalidHeaderName {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("InvalidHeaderName")
+            // skip _priv noise
+            .finish()
+    }
+}
+
+impl fmt::Display for InvalidHeaderName {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("invalid header name")
+    }
+}
+
+impl Error for InvalidHeaderName {}
+
+/// A valid header name
+#[derive(Debug, Clone)]
+pub struct HeaderName(Cow<'static, str>);
+
+impl HeaderName {
+    /// Creates a new header name
+    pub fn new_from_ascii(ascii: String) -> Result<Self, InvalidHeaderName> {
+        if !ascii.is_empty()
+            && ascii.len() <= 76
+            && ascii.is_ascii()
+            && !ascii.contains(|c| c == ':' || c == ' ')
+        {
+            Ok(Self(Cow::Owned(ascii)))
+        } else {
+            Err(InvalidHeaderName { _priv: () })
+        }
+    }
+
+    /// Creates a new header name, panics on invalid name
+    pub const fn new_from_ascii_str(ascii: &'static str) -> Self {
+        macro_rules! static_assert {
+            ($condition:expr) => {
+                let _ = [()][(!($condition)) as usize];
+            };
+        }
+
+        static_assert!(!ascii.is_empty());
+        static_assert!(ascii.len() <= 76);
+
+        let bytes = ascii.as_bytes();
+        let mut i = 0;
+        while i < bytes.len() {
+            static_assert!(bytes[i].is_ascii());
+            static_assert!(bytes[i] != b' ');
+            static_assert!(bytes[i] != b':');
+
+            i += 1;
+        }
+
+        Self(Cow::Borrowed(ascii))
+    }
+}
+
+impl Display for HeaderName {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.write_str(&self)
+    }
+}
+
+impl Deref for HeaderName {
+    type Target = str;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl AsRef<[u8]> for HeaderName {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        let s: &str = self.as_ref();
+        s.as_bytes()
+    }
+}
+
+impl AsRef<str> for HeaderName {
+    #[inline]
+    fn as_ref(&self) -> &str {
+        &self.0
+    }
+}
+
+impl PartialEq<HeaderName> for HeaderName {
+    fn eq(&self, other: &HeaderName) -> bool {
+        let s1: &str = self.as_ref();
+        let s2: &str = other.as_ref();
+        s1 == s2
+    }
+}
+
+impl PartialEq<&str> for HeaderName {
+    fn eq(&self, other: &&str) -> bool {
+        let s: &str = self.as_ref();
+        s == *other
+    }
+}
+
+impl PartialEq<HeaderName> for &str {
+    fn eq(&self, other: &HeaderName) -> bool {
+        let s: &str = other.as_ref();
+        *self == s
+    }
+}
+
+const ENCODING_START_PREFIX: &str = "=?utf-8?b?";
+const ENCODING_END_SUFFIX: &str = "?=";
+const MAX_LINE_LEN: usize = 76;
+
+/// [RFC 1522](https://tools.ietf.org/html/rfc1522) header value encoder
+struct HeaderValueEncoder {
+    line_len: usize,
+    encode_buf: String,
+}
+
+impl HeaderValueEncoder {
+    fn encode(name: &str, value: &str, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let (words_iter, encoder) = Self::new(name, value);
+        encoder.format(words_iter, f)
+    }
+
+    fn new<'a>(name: &str, value: &'a str) -> (WordsPlusFillIterator<'a>, Self) {
+        (
+            WordsPlusFillIterator { s: value },
+            Self {
+                line_len: name.len() + ": ".len(),
+                encode_buf: String::new(),
+            },
+        )
+    }
+
+    fn format(
+        mut self,
+        words_iter: WordsPlusFillIterator<'_>,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        /// Estimate if an encoded string of `len` would fix in an empty line
+        fn would_fit_new_line(len: usize) -> bool {
+            len < (MAX_LINE_LEN - " ".len())
+        }
+
+        /// Estimate how long a string of `len` would be after base64 encoding plus
+        /// adding the encoding prefix and suffix to it
+        fn base64_len(len: usize) -> usize {
+            ENCODING_START_PREFIX.len() + (len * 4 / 3 + 4) + ENCODING_END_SUFFIX.len()
+        }
+
+        /// Estimate how many more bytes we can fit in the current line
+        fn available_len_to_max_encode_len(len: usize) -> usize {
+            len.saturating_sub(
+                ENCODING_START_PREFIX.len() + (len * 3 / 4 + 4) + ENCODING_END_SUFFIX.len(),
+            )
+        }
+
+        for next_word in words_iter {
+            let allowed = allowed_str(next_word);
+
+            if allowed {
+                // This word only contains allowed characters
+
+                // the next word is allowed, but we may have accumulated some words to encode
+                self.flush_encode_buf(f, true)?;
+
+                if next_word.len() > self.remaining_line_len() {
+                    // not enough space left on this line to encode word
+
+                    if self.something_written_to_this_line() && would_fit_new_line(next_word.len())
+                    {
+                        // word doesn't fit this line, but something had already been written to it,
+                        // and word would fit the next line, so go to a new line
+                        // so go to new line
+                        self.new_line(f)?;
+                    } else {
+                        // word neither fits this line and the next one, cut it
+                        // in the middle and make it fit
+
+                        let mut next_word = next_word;
+
+                        while !next_word.is_empty() {
+                            if self.remaining_line_len() == 0 {
+                                self.new_line(f)?;
+                            }
+
+                            let len = self.remaining_line_len().min(next_word.len());
+                            let first_part = &next_word[..len];
+                            next_word = &next_word[len..];
+
+                            f.write_str(first_part)?;
+                            self.line_len += first_part.len();
+                        }
+
+                        continue;
+                    }
+                }
+
+                // word fits, write it!
+                f.write_str(next_word)?;
+                self.line_len += next_word.len();
+            } else {
+                // This word contains unallowed characters
+
+                if self.remaining_line_len() >= base64_len(self.encode_buf.len() + next_word.len())
+                {
+                    // next_word fits
+                    self.encode_buf.push_str(next_word);
+                    continue;
+                }
+
+                // next_word doesn't fit this line
+
+                if would_fit_new_line(base64_len(next_word.len())) {
+                    // ...but it would fit the next one
+
+                    self.flush_encode_buf(f, false)?;
+                    self.new_line(f)?;
+
+                    self.encode_buf.push_str(next_word);
+                    continue;
+                }
+
+                // ...and also wouldn't fit the next one.
+                // chop it up into pieces
+
+                let mut next_word = next_word;
+
+                while !next_word.is_empty() {
+                    if self.remaining_line_len() <= base64_len(1) {
+                        self.flush_encode_buf(f, false)?;
+                        self.new_line(f)?;
+                    }
+
+                    let mut len = available_len_to_max_encode_len(self.remaining_line_len())
+                        .min(next_word.len());
+                    // avoid slicing on a char boundary
+                    while !next_word.is_char_boundary(len) {
+                        len += 1;
+                    }
+                    let first_part = &next_word[..len];
+                    next_word = &next_word[len..];
+
+                    self.encode_buf.push_str(first_part);
+                }
+            }
+        }
+
+        self.flush_encode_buf(f, false)?;
+
+        Ok(())
+    }
+
+    /// Returns the number of bytes left for the current line
+    fn remaining_line_len(&self) -> usize {
+        MAX_LINE_LEN - self.line_len
+    }
+
+    /// Returns true if something has been written to the current line
+    fn something_written_to_this_line(&self) -> bool {
+        self.line_len > 1
+    }
+
+    fn flush_encode_buf(
+        &mut self,
+        f: &mut fmt::Formatter<'_>,
+        switching_to_allowed: bool,
+    ) -> fmt::Result {
+        use std::fmt::Write;
+
+        if self.encode_buf.is_empty() {
+            // nothing to encode
+            return Ok(());
+        }
+
+        let mut write_after = None;
+
+        if switching_to_allowed {
+            // If the next word only contains allowed characters, and the string to encode
+            // ends with a space, take the space out of the part to encode
+
+            let last_char = self.encode_buf.pop().expect("self.encode_buf isn't empty");
+            if is_space_like(last_char) {
+                write_after = Some(last_char);
+            } else {
+                self.encode_buf.push(last_char);
+            }
+        }
+
+        f.write_str(ENCODING_START_PREFIX)?;
+        let encoded = base64::display::Base64Display::with_config(
+            self.encode_buf.as_bytes(),
+            base64::STANDARD,
+        );
+        Display::fmt(&encoded, f)?;
+        f.write_str(ENCODING_END_SUFFIX)?;
+
+        self.line_len += ENCODING_START_PREFIX.len();
+        self.line_len += self.encode_buf.len() * 4 / 3 + 4;
+        self.line_len += ENCODING_END_SUFFIX.len();
+
+        if let Some(write_after) = write_after {
+            f.write_char(write_after)?;
+            self.line_len += 1;
+        }
+
+        self.encode_buf.clear();
+        Ok(())
+    }
+
+    fn new_line(&mut self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("\r\n ")?;
+        self.line_len = 1;
+
+        Ok(())
+    }
+}
+
+/// Iterator yielding a string split space by space, but including all space
+/// characters between it and the next word
+struct WordsPlusFillIterator<'a> {
+    s: &'a str,
+}
+
+impl<'a> Iterator for WordsPlusFillIterator<'a> {
+    type Item = &'a str;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.s.is_empty() {
+            return None;
+        }
+
+        let next_word = self
+            .s
+            .char_indices()
+            .skip(1)
+            .skip_while(|&(_i, c)| !is_space_like(c))
+            .find(|&(_i, c)| !is_space_like(c))
+            .map(|(i, _)| i);
+
+        let word = &self.s[..next_word.unwrap_or_else(|| self.s.len())];
+        self.s = &self.s[word.len()..];
+        Some(word)
+    }
+}
+
+const fn is_space_like(c: char) -> bool {
+    c == ',' || c == ' '
+}
+
+fn allowed_str(s: &str) -> bool {
+    s.chars().all(allowed_char)
+}
+
+const fn allowed_char(c: char) -> bool {
+    c >= 1 as char && c <= 9 as char
+        || c == 11 as char
+        || c == 12 as char
+        || c >= 14 as char && c <= 127 as char
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{HeaderName, Headers};
+
+    #[test]
+    fn valid_headername() {
+        assert!(HeaderName::new_from_ascii(String::from("From")).is_ok());
+    }
+
+    #[test]
+    fn non_ascii_headername() {
+        assert!(HeaderName::new_from_ascii(String::from("🌎")).is_err());
+    }
+
+    #[test]
+    fn spaces_in_headername() {
+        assert!(HeaderName::new_from_ascii(String::from("From ")).is_err());
+    }
+
+    #[test]
+    fn colons_in_headername() {
+        assert!(HeaderName::new_from_ascii(String::from("From:")).is_err());
+    }
+
+    #[test]
+    fn empty_headername() {
+        assert!(HeaderName::new_from_ascii(String::from("")).is_err());
+    }
+
+    #[test]
+    fn const_valid_headername() {
+        let _ = HeaderName::new_from_ascii_str("From");
+    }
+
+    #[test]
+    #[should_panic]
+    fn const_non_ascii_headername() {
+        let _ = HeaderName::new_from_ascii_str("🌎");
+    }
+
+    #[test]
+    #[should_panic]
+    fn const_spaces_in_headername() {
+        let _ = HeaderName::new_from_ascii_str("From ");
+    }
+
+    #[test]
+    #[should_panic]
+    fn const_colons_in_headername() {
+        let _ = HeaderName::new_from_ascii_str("From:");
+    }
+
+    #[test]
+    #[should_panic]
+    fn const_empty_headername() {
+        let _ = HeaderName::new_from_ascii_str("");
+    }
+
+    // names taken randomly from https://it.wikipedia.org/wiki/Pinco_Pallino
+
+    #[test]
+    fn format_ascii() {
+        let mut headers = Headers::new();
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("To"),
+            "John Doe <example@example.com>, Jean Dupont <jean@example.com>".to_string(),
+        );
+
+        assert_eq!(
+            headers.to_string(),
+            "To: John Doe <example@example.com>, Jean Dupont <jean@example.com>\r\n"
+        );
+    }
+
+    #[test]
+    fn format_ascii_with_folding() {
+        let mut headers = Headers::new();
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("To"),
+            "Ascii <example@example.com>, John Doe <johndoe@example.com, John Smith <johnsmith@example.com>, Pinco Pallino <pincopallino@example.com>, Jemand <jemand@example.com>, Jean Dupont <jean@example.com>".to_string(),
+        );
+
+        assert_eq!(
+            headers.to_string(),
+            concat!(
+                "To: Ascii <example@example.com>, John Doe <johndoe@example.com, John Smith \r\n",
+                " <johnsmith@example.com>, Pinco Pallino <pincopallino@example.com>, Jemand \r\n",
+                " <jemand@example.com>, Jean Dupont <jean@example.com>\r\n"
+            )
+        );
+    }
+
+    #[test]
+    fn format_ascii_with_folding_long_line() {
+        let mut headers = Headers::new();
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("Subject"),
+            "Hello! This is lettre, and this IsAVeryLongLineDoYouKnowWhatsGoingToHappenIGuessWeAreGoingToFindOut. Ok I guess that's it!".to_string()
+        );
+
+        assert_eq!(
+            headers.to_string(),
+            concat!(
+                "Subject: Hello! This is lettre, and this \r\n ",
+                "IsAVeryLongLineDoYouKnowWhatsGoingToHappenIGuessWeAreGoingToFindOut. Ok I \r\n",
+                " guess that's it!\r\n"
+            )
+        );
+    }
+
+    #[test]
+    fn format_ascii_with_folding_very_long_line() {
+        let mut headers = Headers::new();
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("Subject"),
+            "Hello! IGuessTheLastLineWasntLongEnoughSoLetsTryAgainShallWeWhatDoYouThinkItsGoingToHappenIGuessWereAboutToFindOut! I don't know".to_string()
+        );
+
+        assert_eq!(
+            headers.to_string(),
+            concat!(
+                "Subject: Hello! IGuessTheLastLineWasntLongEnoughSoLetsTryAgainShallWeWhatDoY\r\n",
+                " ouThinkItsGoingToHappenIGuessWereAboutToFindOut! I don't know\r\n",
+            )
+        );
+    }
+
+    #[test]
+    fn format_ascii_with_folding_giant_word() {
+        let mut headers = Headers::new();
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("Subject"),
+            "1abcdefghijklmnopqrstuvwxyz2abcdefghijklmnopqrstuvwxyz3abcdefghijklmnopqrstuvwxyz4abcdefghijklmnopqrstuvwxyz5abcdefghijklmnopqrstuvwxyz6abcdefghijklmnopqrstuvwxyz".to_string()
+        );
+
+        assert_eq!(
+            headers.to_string(),
+            concat!(
+                "Subject: 1abcdefghijklmnopqrstuvwxyz2abcdefghijklmnopqrstuvwxyz3abcdefghijkl\r\n",
+                " mnopqrstuvwxyz4abcdefghijklmnopqrstuvwxyz5abcdefghijklmnopqrstuvwxyz6abcdef\r\n",
+                " ghijklmnopqrstuvwxyz\r\n",
+            )
+        );
+    }
+
+    #[test]
+    fn format_special() {
+        let mut headers = Headers::new();
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("To"),
+            "Seán <sean@example.com>".to_string(),
+        );
+
+        assert_eq!(
+            headers.to_string(),
+            "To: =?utf-8?b?U2XDoW4=?= <sean@example.com>\r\n"
+        );
+    }
+
+    #[test]
+    fn format_special_emoji() {
+        let mut headers = Headers::new();
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("To"),
+            "🌎 <world@example.com>".to_string(),
+        );
+
+        assert_eq!(
+            headers.to_string(),
+            "To: =?utf-8?b?8J+Mjg==?= <world@example.com>\r\n"
+        );
+    }
+
+    #[test]
+    fn format_special_with_folding() {
+        let mut headers = Headers::new();
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("To"),
+            "🌍 <world@example.com>, 🦆 Everywhere <ducks@example.com>, Иванов Иван Иванович <ivanov@example.com>, Jānis Bērziņš <janis@example.com>, Seán Ó Rudaí <sean@example.com>".to_string(),
+        );
+
+        assert_eq!(
+            headers.to_string(),
+            concat!(
+                "To: =?utf-8?b?8J+MjQ==?= <world@example.com>, =?utf-8?b?8J+mhg==?= \r\n",
+                " Everywhere <ducks@example.com>, =?utf-8?b?0JjQstCw0L3QvtCyIA==?=\r\n",
+                " =?utf-8?b?0JjQstCw0L0g0JjQstCw0L3QvtCy0LjRhw==?= <ivanov@example.com>, \r\n",
+                " =?utf-8?b?SsSBbmlzIELEk3J6acWGxaE=?= <janis@example.com>, \r\n",
+                " =?utf-8?b?U2XDoW4gw5MgUnVkYcOt?= <sean@example.com>\r\n"
+            )
+        );
+    }
+
+    #[test]
+    fn format_slice_on_char_boundary_bug() {
+        let mut headers = Headers::new();
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("Subject"),
+            "🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳".to_string(),
+        );
+
+        assert_eq!(
+            headers.to_string(),
+            "Subject: =?utf-8?b?8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz?=\r\n"
+        );
+    }
+
+    #[test]
+    fn format_bad_stuff() {
+        let mut headers = Headers::new();
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("Subject"),
+            "Hello! \r\n This is \" bad \0. 👋".to_string(),
+        );
+
+        assert_eq!(
+            headers.to_string(),
+            "Subject: Hello! =?utf-8?b?DQo=?= This is \" bad =?utf-8?b?AC4g8J+Riw==?=\r\n"
+        );
+    }
+
+    #[test]
+    fn format_everything() {
+        let mut headers = Headers::new();
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("Subject"),
+            "Hello! This is lettre, and this IsAVeryLongLineDoYouKnowWhatsGoingToHappenIGuessWeAreGoingToFindOut. Ok I guess that's it!".to_string()
+        );
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("To"),
+            "🌍 <world@example.com>, 🦆 Everywhere <ducks@example.com>, Иванов Иван Иванович <ivanov@example.com>, Jānis Bērziņš <janis@example.com>, Seán Ó Rudaí <sean@example.com>".to_string(),
+        );
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("From"),
+            "Someone <somewhere@example.com>".to_string(),
+        );
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("Content-Transfer-Encoding"),
+            "quoted-printable".to_string(),
+        );
+
+        assert_eq!(
+            headers.to_string(),
+            concat!(
+                "Subject: Hello! This is lettre, and this \r\n",
+                " IsAVeryLongLineDoYouKnowWhatsGoingToHappenIGuessWeAreGoingToFindOut. Ok I \r\n",
+                " guess that's it!\r\n",
+                "To: =?utf-8?b?8J+MjQ==?= <world@example.com>, =?utf-8?b?8J+mhg==?= \r\n",
+                " Everywhere <ducks@example.com>, =?utf-8?b?0JjQstCw0L3QvtCyIA==?=\r\n",
+                " =?utf-8?b?0JjQstCw0L0g0JjQstCw0L3QvtCy0LjRhw==?= <ivanov@example.com>, \r\n",
+                " =?utf-8?b?SsSBbmlzIELEk3J6acWGxaE=?= <janis@example.com>, \r\n",
+                " =?utf-8?b?U2XDoW4gw5MgUnVkYcOt?= <sean@example.com>\r\n",
+                "From: Someone <somewhere@example.com>\r\n",
+                "Content-Transfer-Encoding: quoted-printable\r\n",
+            )
+        );
+    }
+}

src/message/header/special.rs

@@ -1,22 +1,55 @@
-use hyperx::{
-    header::{Formatter as HeaderFormatter, Header, RawLike},
-    Error as HeaderError, Result as HyperResult,
+use crate::{
+    message::header::{Header, HeaderName},
+    BoxError,
 };
-use std::{fmt::Result as FmtResult, str::from_utf8};
 
-#[derive(Debug, Clone, Copy, PartialEq)]
 /// Message format version, defined in [RFC2045](https://tools.ietf.org/html/rfc2045#section-4)
+#[derive(Debug, Copy, Clone, PartialEq)]
 pub struct MimeVersion {
-    pub major: u8,
-    pub minor: u8,
+    major: u8,
+    minor: u8,
 }
 
-pub const MIME_VERSION_1_0: MimeVersion = MimeVersion { major: 1, minor: 0 };
+pub const MIME_VERSION_1_0: MimeVersion = MimeVersion::new(1, 0);
 
 impl MimeVersion {
-    pub fn new(major: u8, minor: u8) -> Self {
+    pub const fn new(major: u8, minor: u8) -> Self {
         MimeVersion { major, minor }
     }
+
+    #[inline]
+    pub const fn major(self) -> u8 {
+        self.major
+    }
+
+    #[inline]
+    pub const fn minor(self) -> u8 {
+        self.minor
+    }
+}
+
+impl Header for MimeVersion {
+    fn name() -> HeaderName {
+        HeaderName::new_from_ascii_str("MIME-Version")
+    }
+
+    fn parse(s: &str) -> Result<Self, BoxError> {
+        let mut s = s.split('.');
+
+        let major = s
+            .next()
+            .expect("The first call to next for a Split<char> always succeeds");
+        let minor = s
+            .next()
+            .ok_or_else(|| String::from("MIME-Version header doesn't contain '.'"))?;
+        let major = major.parse()?;
+        let minor = minor.parse()?;
+        Ok(MimeVersion::new(major, minor))
+    }
+
+    fn display(&self) -> String {
+        format!("{}.{}", self.major, self.minor)
+    }
 }
 
 impl Default for MimeVersion {
@@ -25,36 +58,10 @@ impl Default for MimeVersion {
     }
 }
 
-impl Header for MimeVersion {
-    fn header_name() -> &'static str {
-        "MIME-Version"
-    }
-
-    fn parse_header<'a, T>(raw: &'a T) -> HyperResult<Self>
-    where
-        T: RawLike<'a>,
-        Self: Sized,
-    {
-        raw.one().ok_or(HeaderError::Header).and_then(|r| {
-            let mut s = from_utf8(r).map_err(|_| HeaderError::Header)?.split('.');
-
-            let major = s.next().ok_or(HeaderError::Header)?;
-            let minor = s.next().ok_or(HeaderError::Header)?;
-            let major = major.parse().map_err(|_| HeaderError::Header)?;
-            let minor = minor.parse().map_err(|_| HeaderError::Header)?;
-            Ok(MimeVersion::new(major, minor))
-        })
-    }
-
-    fn fmt_header(&self, f: &mut HeaderFormatter<'_, '_>) -> FmtResult {
-        f.fmt_line(&format!("{}.{}", self.major, self.minor))
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::{MimeVersion, MIME_VERSION_1_0};
-    use hyperx::header::Headers;
+    use crate::message::header::{HeaderName, Headers};
 
     #[test]
     fn format_mime_version() {
@@ -62,23 +69,29 @@ mod test {
 
         headers.set(MIME_VERSION_1_0);
 
-        assert_eq!(format!("{}", headers), "MIME-Version: 1.0\r\n");
+        assert_eq!(headers.to_string(), "MIME-Version: 1.0\r\n");
 
         headers.set(MimeVersion::new(0, 1));
 
-        assert_eq!(format!("{}", headers), "MIME-Version: 0.1\r\n");
+        assert_eq!(headers.to_string(), "MIME-Version: 0.1\r\n");
     }
 
     #[test]
     fn parse_mime_version() {
         let mut headers = Headers::new();
 
-        headers.set_raw("MIME-Version", "1.0");
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("MIME-Version"),
+            "1.0".to_string(),
+        );
 
-        assert_eq!(headers.get::<MimeVersion>(), Some(&MIME_VERSION_1_0));
+        assert_eq!(headers.get::<MimeVersion>(), Some(MIME_VERSION_1_0));
 
-        headers.set_raw("MIME-Version", "0.1");
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("MIME-Version"),
+            "0.1".to_string(),
+        );
 
-        assert_eq!(headers.get::<MimeVersion>(), Some(&MimeVersion::new(0, 1)));
+        assert_eq!(headers.get::<MimeVersion>(), Some(MimeVersion::new(0, 1)));
     }
 }

src/message/header/textual.rs

@@ -1,34 +1,37 @@
-use crate::message::utf8_b;
-use hyperx::{
-    header::{Formatter as HeaderFormatter, Header, RawLike},
-    Error as HeaderError, Result as HyperResult,
-};
-use std::{fmt::Result as FmtResult, str::from_utf8};
+use super::{Header, HeaderName};
+use crate::BoxError;
 
 macro_rules! text_header {
     ($(#[$attr:meta])* Header($type_name: ident, $header_name: expr )) => {
-        #[derive(Debug, Clone, PartialEq)]
         $(#[$attr])*
-        pub struct $type_name(pub String);
+        #[derive(Debug, Clone, PartialEq)]
+        pub struct $type_name(String);
 
         impl Header for $type_name {
-            fn header_name() -> &'static str {
-                $header_name
+            fn name() -> HeaderName {
+                HeaderName::new_from_ascii_str($header_name)
             }
 
-            fn parse_header<'a, T>(raw: &'a T) -> HyperResult<$type_name>
-            where
-                T: RawLike<'a>,
-                Self: Sized,
-            {
-                raw.one()
-                    .ok_or(HeaderError::Header)
-                    .and_then(parse_text)
-                    .map($type_name)
+            fn parse(s: &str) -> Result<Self, BoxError> {
+                Ok(Self(s.into()))
             }
 
-            fn fmt_header(&self, f: &mut HeaderFormatter<'_, '_>) -> FmtResult {
-                fmt_text(&self.0, f)
+            fn display(&self) -> String {
+                self.0.clone()
+            }
+        }
+
+        impl From<String> for $type_name {
+            #[inline]
+            fn from(text: String) -> Self {
+                Self(text)
+            }
+        }
+
+        impl AsRef<str> for $type_name {
+            #[inline]
+            fn as_ref(&self) -> &str {
+                &self.0
             }
         }
     };
@@ -62,38 +65,35 @@ text_header!(
 text_header!(
     /// `Message-Id` header. Contains a unique message identifier,
     /// defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.4)
-    Header(MessageId, "Message-Id")
+    Header(MessageId, "Message-ID")
 );
 text_header!(
     /// `User-Agent` header. Contains information about the client,
     /// defined in [draft-melnikov-email-user-agent-00](https://tools.ietf.org/html/draft-melnikov-email-user-agent-00#section-3)
     Header(UserAgent, "User-Agent")
 );
-
-fn parse_text(raw: &[u8]) -> HyperResult<String> {
-    if let Ok(src) = from_utf8(raw) {
-        if let Some(txt) = utf8_b::decode(src) {
-            return Ok(txt);
-        }
-    }
-    Err(HeaderError::Header)
+text_header! {
+    /// `Content-Id` header,
+    /// defined in [RFC2045](https://tools.ietf.org/html/rfc2045#section-7)
+    Header(ContentId, "Content-ID")
 }
-
-fn fmt_text(s: &str, f: &mut HeaderFormatter<'_, '_>) -> FmtResult {
-    f.fmt_line(&utf8_b::encode(s))
+text_header! {
+    /// `Content-Location` header,
+    /// defined in [RFC2110](https://tools.ietf.org/html/rfc2110#section-4.3)
+    Header(ContentLocation, "Content-Location")
 }
 
 #[cfg(test)]
 mod test {
     use super::Subject;
-    use hyperx::header::Headers;
+    use crate::message::header::{HeaderName, Headers};
 
     #[test]
     fn format_ascii() {
         let mut headers = Headers::new();
         headers.set(Subject("Sample subject".into()));
 
-        assert_eq!(format!("{}", headers), "Subject: Sample subject\r\n");
+        assert_eq!(headers.to_string(), "Subject: Sample subject\r\n");
     }
 
     #[test]
@@ -102,7 +102,7 @@ mod test {
         headers.set(Subject("Тема сообщения".into()));
 
         assert_eq!(
-            format!("{}", headers),
+            headers.to_string(),
             "Subject: =?utf-8?b?0KLQtdC80LAg0YHQvtC+0LHRidC10L3QuNGP?=\r\n"
         );
     }
@@ -110,25 +110,14 @@ mod test {
     #[test]
     fn parse_ascii() {
         let mut headers = Headers::new();
-        headers.set_raw("Subject", "Sample subject");
-
-        assert_eq!(
-            headers.get::<Subject>(),
-            Some(&Subject("Sample subject".into()))
-        );
-    }
-
-    #[test]
-    fn parse_utf8() {
-        let mut headers = Headers::new();
-        headers.set_raw(
-            "Subject",
-            "=?utf-8?b?0KLQtdC80LAg0YHQvtC+0LHRidC10L3QuNGP?=",
+        headers.insert_raw(
+            HeaderName::new_from_ascii_str("Subject"),
+            "Sample subject".to_string(),
         );
 
         assert_eq!(
             headers.get::<Subject>(),
-            Some(&Subject("Тема сообщения".into()))
+            Some(Subject("Sample subject".into()))
         );
     }
 }

src/message/mailbox/types.rs

@@ -1,7 +1,4 @@
-use crate::{
-    address::{Address, AddressError},
-    message::utf8_b,
-};
+use crate::address::{Address, AddressError};
 use std::{
     convert::TryFrom,
     fmt::{Display, Formatter, Result as FmtResult, Write},
@@ -66,14 +63,6 @@ impl Mailbox {
     pub fn new(name: Option<String>, email: Address) -> Self {
         Mailbox { name, email }
     }
-
-    /// Encode addressee name using function
-    pub(crate) fn recode_name<F>(&self, f: F) -> Self
-    where
-        F: FnOnce(&str) -> String,
-    {
-        Mailbox::new(self.name.clone().map(|s| f(&s)), self.email.clone())
-    }
 }
 
 impl Display for Mailbox {
@@ -332,19 +321,7 @@ impl FromStr for Mailboxes {
 
     fn from_str(src: &str) -> Result<Self, Self::Err> {
         src.split(',')
-            .map(|m| {
-                m.trim().parse().and_then(|Mailbox { name, email }| {
-                    if let Some(name) = name {
-                        if let Some(name) = utf8_b::decode(&name) {
-                            Ok(Mailbox::new(Some(name), email))
-                        } else {
-                            Err(AddressError::InvalidUtf8b)
-                        }
-                    } else {
-                        Ok(Mailbox::new(None, email))
-                    }
-                })
-            })
+            .map(|m| m.trim().parse())
             .collect::<Result<Vec<_>, _>>()
             .map(Mailboxes)
     }

src/message/mimebody.rs

@@ -1,13 +1,15 @@
+use std::io::Write;
+
 use crate::message::{
-    header::{ContentTransferEncoding, ContentType, Header, Headers},
+    header::{self, ContentTransferEncoding, ContentType, Header, Headers},
     EmailFormat, IntoBody,
 };
 use mime::Mime;
-use rand::Rng;
+use std::iter::repeat_with;
 
 /// MIME part variants
 #[derive(Debug, Clone)]
-pub enum Part {
+pub(super) enum Part {
     /// Single part with content
     Single(SinglePart),
 
@@ -24,18 +26,6 @@ impl EmailFormat for Part {
     }
 }
 
-impl Part {
-    /// Get message content formatted for SMTP
-    pub fn formatted(&self) -> Vec<u8> {
-        let mut out = Vec::new();
-        self.format(&mut out);
-        out
-    }
-}
-
-/// Parts of multipart body
-pub type Parts = Vec<Part>;
-
 /// Creates builder for single part
 #[derive(Debug, Clone)]
 pub struct SinglePartBuilder {
@@ -64,7 +54,7 @@ impl SinglePartBuilder {
 
     /// Build singlepart using body
     pub fn body<T: IntoBody>(mut self, body: T) -> SinglePart {
-        let maybe_encoding = self.headers.get::<ContentTransferEncoding>().copied();
+        let maybe_encoding = self.headers.get::<ContentTransferEncoding>();
         let body = body.into_body(maybe_encoding);
 
         self.headers.set(body.encoding());
@@ -92,7 +82,7 @@ impl Default for SinglePartBuilder {
 /// # use std::error::Error;
 /// # fn main() -> Result<(), Box<dyn Error>> {
 /// let part = SinglePart::builder()
-///     .header(header::ContentType("text/plain; charset=utf8".parse()?))
+///     .header(header::ContentType::TEXT_PLAIN)
 ///     .body(String::from("Текст письма в уникоде"));
 /// # Ok(())
 /// # }
@@ -110,6 +100,20 @@ impl SinglePart {
         SinglePartBuilder::new()
     }
 
+    /// Directly create a `SinglePart` from an plain UTF-8 content
+    pub fn plain<T: IntoBody>(body: T) -> Self {
+        Self::builder()
+            .header(header::ContentType::TEXT_PLAIN)
+            .body(body)
+    }
+
+    /// Directly create a `SinglePart` from an UTF-8 HTML content
+    pub fn html<T: IntoBody>(body: T) -> Self {
+        Self::builder()
+            .header(header::ContentType::TEXT_HTML)
+            .body(body)
+    }
+
     /// Get the headers from singlepart
     #[inline]
     pub fn headers(&self) -> &Headers {
@@ -132,7 +136,8 @@ impl SinglePart {
 
 impl EmailFormat for SinglePart {
     fn format(&self, out: &mut Vec<u8>) {
-        out.extend_from_slice(self.headers.to_string().as_bytes());
+        write!(out, "{}", self.headers)
+            .expect("A Write implementation panicked while formatting headers");
         out.extend_from_slice(b"\r\n");
         out.extend_from_slice(&self.body);
         out.extend_from_slice(b"\r\n");
@@ -165,17 +170,14 @@ pub enum MultiPartKind {
 }
 
 /// Create a random MIME boundary.
+/// (Not cryptographically random)
 fn make_boundary() -> String {
-    rand::thread_rng()
-        .sample_iter(rand::distributions::Alphanumeric)
-        .take(40)
-        .map(char::from)
-        .collect()
+    repeat_with(fastrand::alphanumeric).take(40).collect()
 }
 
 impl MultiPartKind {
-    fn to_mime<S: Into<String>>(&self, boundary: Option<S>) -> Mime {
-        let boundary = boundary.map_or_else(make_boundary, |s| s.into());
+    pub(crate) fn to_mime<S: Into<String>>(&self, boundary: Option<S>) -> Mime {
+        let boundary = boundary.map_or_else(make_boundary, Into::into);
 
         format!(
             "multipart/{}; boundary=\"{}\"{}",
@@ -217,12 +219,6 @@ impl MultiPartKind {
     }
 }
 
-impl From<MultiPartKind> for Mime {
-    fn from(m: MultiPartKind) -> Self {
-        m.to_mime::<String>(None)
-    }
-}
-
 /// Multipart builder
 #[derive(Debug, Clone)]
 pub struct MultiPartBuilder {
@@ -245,17 +241,17 @@ impl MultiPartBuilder {
 
     /// Set `Content-Type` header using [`MultiPartKind`]
     pub fn kind(self, kind: MultiPartKind) -> Self {
-        self.header(ContentType(kind.into()))
+        self.header(ContentType::from_mime(kind.to_mime::<String>(None)))
     }
 
     /// Set custom boundary
-    pub fn boundary<S: AsRef<str>>(self, boundary: S) -> Self {
+    pub fn boundary<S: Into<String>>(self, boundary: S) -> Self {
         let kind = {
-            let mime = &self.headers.get::<ContentType>().unwrap().0;
-            MultiPartKind::from_mime(mime).unwrap()
+            let content_type = self.headers.get::<ContentType>().unwrap();
+            MultiPartKind::from_mime(content_type.as_ref()).unwrap()
         };
-        let mime = kind.to_mime(Some(boundary.as_ref()));
-        self.header(ContentType(mime))
+        let mime = kind.to_mime(Some(boundary));
+        self.header(ContentType::from_mime(mime))
     }
 
     /// Creates multipart without parts
@@ -266,11 +262,6 @@ impl MultiPartBuilder {
         }
     }
 
-    /// Creates multipart using part
-    pub fn part(self, part: Part) -> MultiPart {
-        self.build().part(part)
-    }
-
     /// Creates multipart using singlepart
     pub fn singlepart(self, part: SinglePart) -> MultiPart {
         self.build().singlepart(part)
@@ -292,7 +283,7 @@ impl Default for MultiPartBuilder {
 #[derive(Debug, Clone)]
 pub struct MultiPart {
     headers: Headers,
-    parts: Parts,
+    parts: Vec<Part>,
 }
 
 impl MultiPart {
@@ -336,10 +327,11 @@ impl MultiPart {
         MultiPart::builder().kind(MultiPartKind::Signed { protocol, micalg })
     }
 
-    /// Add part to multipart
-    pub fn part(mut self, part: Part) -> Self {
-        self.parts.push(part);
-        self
+    /// Alias for HTML and plain text versions of an email
+    pub fn alternative_plain_html<T: IntoBody, V: IntoBody>(plain: T, html: V) -> Self {
+        Self::alternative()
+            .singlepart(SinglePart::plain(plain))
+            .singlepart(SinglePart::html(html))
     }
 
     /// Add single part to multipart
@@ -356,8 +348,13 @@ impl MultiPart {
 
     /// Get the boundary of multipart contents
     pub fn boundary(&self) -> String {
-        let content_type = &self.headers.get::<ContentType>().unwrap().0;
-        content_type.get_param("boundary").unwrap().as_str().into()
+        let content_type = self.headers.get::<ContentType>().unwrap();
+        content_type
+            .as_ref()
+            .get_param("boundary")
+            .unwrap()
+            .as_str()
+            .into()
     }
 
     /// Get the headers from the multipart
@@ -370,16 +367,6 @@ impl MultiPart {
         &mut self.headers
     }
 
-    /// Get the parts from the multipart
-    pub fn parts(&self) -> &Parts {
-        &self.parts
-    }
-
-    /// Get a mutable reference to the parts
-    pub fn parts_mut(&mut self) -> &mut Parts {
-        &mut self.parts
-    }
-
     /// Get message content formatted for SMTP
     pub fn formatted(&self) -> Vec<u8> {
         let mut out = Vec::new();
@@ -390,7 +377,8 @@ impl MultiPart {
 
 impl EmailFormat for MultiPart {
     fn format(&self, out: &mut Vec<u8>) {
-        out.extend_from_slice(self.headers.to_string().as_bytes());
+        write!(out, "{}", self.headers)
+            .expect("A Write implementation panicked while formatting headers");
         out.extend_from_slice(b"\r\n");
 
         let boundary = self.boundary();
@@ -416,16 +404,14 @@ mod test {
     #[test]
     fn single_part_binary() {
         let part = SinglePart::builder()
-            .header(header::ContentType(
-                "text/plain; charset=utf8".parse().unwrap(),
-            ))
+            .header(header::ContentType::TEXT_PLAIN)
             .header(header::ContentTransferEncoding::Binary)
             .body(String::from("Текст письма в уникоде"));
 
         assert_eq!(
             String::from_utf8(part.formatted()).unwrap(),
             concat!(
-                "Content-Type: text/plain; charset=utf8\r\n",
+                "Content-Type: text/plain; charset=utf-8\r\n",
                 "Content-Transfer-Encoding: binary\r\n",
                 "\r\n",
                 "Текст письма в уникоде\r\n"
@@ -436,16 +422,14 @@ mod test {
     #[test]
     fn single_part_quoted_printable() {
         let part = SinglePart::builder()
-            .header(header::ContentType(
-                "text/plain; charset=utf8".parse().unwrap(),
-            ))
+            .header(header::ContentType::TEXT_PLAIN)
             .header(header::ContentTransferEncoding::QuotedPrintable)
             .body(String::from("Текст письма в уникоде"));
 
         assert_eq!(
             String::from_utf8(part.formatted()).unwrap(),
             concat!(
-                "Content-Type: text/plain; charset=utf8\r\n",
+                "Content-Type: text/plain; charset=utf-8\r\n",
                 "Content-Transfer-Encoding: quoted-printable\r\n",
                 "\r\n",
                 "=D0=A2=D0=B5=D0=BA=D1=81=D1=82 =D0=BF=D0=B8=D1=81=D1=8C=D0=BC=D0=B0 =D0=B2 =\r\n",
@@ -457,16 +441,14 @@ mod test {
     #[test]
     fn single_part_base64() {
         let part = SinglePart::builder()
-            .header(header::ContentType(
-                "text/plain; charset=utf8".parse().unwrap(),
-            ))
+            .header(header::ContentType::TEXT_PLAIN)
             .header(header::ContentTransferEncoding::Base64)
             .body(String::from("Текст письма в уникоде"));
 
         assert_eq!(
             String::from_utf8(part.formatted()).unwrap(),
             concat!(
-                "Content-Type: text/plain; charset=utf8\r\n",
+                "Content-Type: text/plain; charset=utf-8\r\n",
                 "Content-Transfer-Encoding: base64\r\n",
                 "\r\n",
                 "0KLQtdC60YHRgiDQv9C40YHRjNC80LAg0LIg0YPQvdC40LrQvtC00LU=\r\n"
@@ -477,75 +459,60 @@ mod test {
     #[test]
     fn multi_part_mixed() {
         let part = MultiPart::mixed()
-            .boundary("F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK")
-            .part(Part::Single(
-                SinglePart::builder()
-                    .header(header::ContentType(
-                        "text/plain; charset=utf8".parse().unwrap(),
-                    ))
-                    .header(header::ContentTransferEncoding::Binary)
-                    .body(String::from("Текст письма в уникоде")),
-            ))
+            .boundary("0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1")
             .singlepart(
                 SinglePart::builder()
-                    .header(header::ContentType(
-                        "text/plain; charset=utf8".parse().unwrap(),
-                    ))
-                    .header(header::ContentDisposition {
-                        disposition: header::DispositionType::Attachment,
-                        parameters: vec![header::DispositionParam::Filename(
-                            header::Charset::Ext("utf-8".into()),
-                            None,
-                            "example.c".into(),
-                        )],
-                    })
+                    .header(header::ContentType::TEXT_PLAIN)
+                    .header(header::ContentTransferEncoding::Binary)
+                    .body(String::from("Текст письма в уникоде")),
+            )
+            .singlepart(
+                SinglePart::builder()
+                    .header(header::ContentType::TEXT_PLAIN)
+                    .header(header::ContentDisposition::attachment("example.c"))
                     .header(header::ContentTransferEncoding::Binary)
                     .body(String::from("int main() { return 0; }")),
             );
 
-        assert_eq!(String::from_utf8(part.formatted()).unwrap(),
-                   concat!("Content-Type: multipart/mixed;",
-                           " boundary=\"F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK\"\r\n",
-                           "\r\n",
-                           "--F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK\r\n",
-                           "Content-Type: text/plain; charset=utf8\r\n",
-                           "Content-Transfer-Encoding: binary\r\n",
-                           "\r\n",
-                           "Текст письма в уникоде\r\n",
-                           "--F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK\r\n",
-                           "Content-Type: text/plain; charset=utf8\r\n",
-                           "Content-Disposition: attachment; filename=\"example.c\"\r\n",
-                           "Content-Transfer-Encoding: binary\r\n",
-                           "\r\n",
-                           "int main() { return 0; }\r\n",
-                           "--F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK--\r\n"));
+        assert_eq!(
+            String::from_utf8(part.formatted()).unwrap(),
+            concat!(
+                "Content-Type: multipart/mixed; \r\n",
+                " boundary=\"0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\"\r\n",
+                "\r\n",
+                "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
+                "Content-Type: text/plain; charset=utf-8\r\n",
+                "Content-Transfer-Encoding: binary\r\n",
+                "\r\n",
+                "Текст письма в уникоде\r\n",
+                "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
+                "Content-Type: text/plain; charset=utf-8\r\n",
+                "Content-Disposition: attachment; filename=\"example.c\"\r\n",
+                "Content-Transfer-Encoding: binary\r\n",
+                "\r\n",
+                "int main() { return 0; }\r\n",
+                "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1--\r\n"
+            )
+        );
     }
     #[test]
     fn multi_part_encrypted() {
         let part = MultiPart::encrypted("application/pgp-encrypted".to_owned())
-            .boundary("F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK")
-            .part(Part::Single(
-                SinglePart::builder()
-                    .header(header::ContentType(
-                        "application/pgp-encrypted".parse().unwrap(),
-                    ))
-                    .body(String::from("Version: 1")),
-            ))
+            .boundary("0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1")
             .singlepart(
                 SinglePart::builder()
-                    .header(ContentType(
-                        "application/octet-stream; name=\"encrypted.asc\""
-                            .parse()
+                    .header(header::ContentType::parse("application/pgp-encrypted").unwrap())
+                    .body(String::from("Version: 1")),
+            )
+            .singlepart(
+                SinglePart::builder()
+                    .header(
+                        ContentType::parse("application/octet-stream; name=\"encrypted.asc\"")
                             .unwrap(),
+                    )
+                    .header(header::ContentDisposition::inline_with_name(
+                        "encrypted.asc",
                     ))
-                    .header(header::ContentDisposition {
-                        disposition: header::DispositionType::Inline,
-                        parameters: vec![header::DispositionParam::Filename(
-                            header::Charset::Ext("utf-8".into()),
-                            None,
-                            "encrypted.asc".into(),
-                        )],
-                    })
                     .body(String::from(concat!(
                         "-----BEGIN PGP MESSAGE-----\r\n",
                         "wV4D0dz5vDXklO8SAQdA5lGX1UU/eVQqDxNYdHa7tukoingHzqUB6wQssbMfHl8w\r\n",
@@ -554,27 +521,31 @@ mod test {
                     ))),
             );
 
-        assert_eq!(String::from_utf8(part.formatted()).unwrap(),
-                   concat!("Content-Type: multipart/encrypted;",
-                           " boundary=\"F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK\";",
-                           " protocol=\"application/pgp-encrypted\"\r\n",
-                           "\r\n",
-                           "--F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK\r\n",
-                           "Content-Type: application/pgp-encrypted\r\n",
-                           "Content-Transfer-Encoding: 7bit\r\n",
-                           "\r\n",
-                           "Version: 1\r\n",
-                           "--F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK\r\n",
-                           "Content-Type: application/octet-stream; name=\"encrypted.asc\"\r\n",
-                           "Content-Disposition: inline; filename=\"encrypted.asc\"\r\n",
-                           "Content-Transfer-Encoding: 7bit\r\n",
-                           "\r\n",
-                           "-----BEGIN PGP MESSAGE-----\r\n",
-                           "wV4D0dz5vDXklO8SAQdA5lGX1UU/eVQqDxNYdHa7tukoingHzqUB6wQssbMfHl8w\r\n",
-                           "...\r\n",
-                           "-----END PGP MESSAGE-----\r\n",
-                           "\r\n",
-                           "--F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK--\r\n"));
+        assert_eq!(
+            String::from_utf8(part.formatted()).unwrap(),
+            concat!(
+                "Content-Type: multipart/encrypted; \r\n",
+                " boundary=\"0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\"; \r\n",
+                " protocol=\"application/pgp-encrypted\"\r\n",
+                "\r\n",
+                "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
+                "Content-Type: application/pgp-encrypted\r\n",
+                "Content-Transfer-Encoding: 7bit\r\n",
+                "\r\n",
+                "Version: 1\r\n",
+                "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
+                "Content-Type: application/octet-stream; name=\"encrypted.asc\"\r\n",
+                "Content-Disposition: inline; filename=\"encrypted.asc\"\r\n",
+                "Content-Transfer-Encoding: 7bit\r\n",
+                "\r\n",
+                "-----BEGIN PGP MESSAGE-----\r\n",
+                "wV4D0dz5vDXklO8SAQdA5lGX1UU/eVQqDxNYdHa7tukoingHzqUB6wQssbMfHl8w\r\n",
+                "...\r\n",
+                "-----END PGP MESSAGE-----\r\n",
+                "\r\n",
+                "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1--\r\n"
+            )
+        );
     }
     #[test]
     fn multi_part_signed() {
@@ -582,27 +553,19 @@ mod test {
             "application/pgp-signature".to_owned(),
             "pgp-sha256".to_owned(),
         )
-        .boundary("F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK")
-        .part(Part::Single(
-            SinglePart::builder()
-                .header(header::ContentType("text/plain".parse().unwrap()))
-                .body(String::from("Test email for signature")),
-        ))
+        .boundary("0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1")
         .singlepart(
             SinglePart::builder()
-                .header(ContentType(
-                    "application/pgp-signature; name=\"signature.asc\""
-                        .parse()
+                .header(header::ContentType::TEXT_PLAIN)
+                .body(String::from("Test email for signature")),
+        )
+        .singlepart(
+            SinglePart::builder()
+                .header(
+                    ContentType::parse("application/pgp-signature; name=\"signature.asc\"")
                         .unwrap(),
-                ))
-                .header(header::ContentDisposition {
-                    disposition: header::DispositionType::Attachment,
-                    parameters: vec![header::DispositionParam::Filename(
-                        header::Charset::Ext("utf-8".into()),
-                        None,
-                        "signature.asc".into(),
-                    )],
-                })
+                )
+                .header(header::ContentDisposition::attachment("signature.asc"))
                 .body(String::from(concat!(
                     "-----BEGIN PGP SIGNATURE-----\r\n",
                     "\r\n",
@@ -614,101 +577,102 @@ mod test {
                 ))),
         );
 
-        assert_eq!(String::from_utf8(part.formatted()).unwrap(),
-                   concat!("Content-Type: multipart/signed;",
-                           " boundary=\"F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK\";",
-                           " protocol=\"application/pgp-signature\";",
-                           " micalg=\"pgp-sha256\"\r\n",
-                           "\r\n",
-                           "--F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK\r\n",
-                           "Content-Type: text/plain\r\n",
-                           "Content-Transfer-Encoding: 7bit\r\n",
-                           "\r\n",
-                           "Test email for signature\r\n",
-                           "--F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK\r\n",
-                           "Content-Type: application/pgp-signature; name=\"signature.asc\"\r\n",
-                           "Content-Disposition: attachment; filename=\"signature.asc\"\r\n",
-                           "Content-Transfer-Encoding: 7bit\r\n",
-                           "\r\n",
-                           "-----BEGIN PGP SIGNATURE-----\r\n",
-                            "\r\n",
-                            "iHUEARYIAB0WIQTNsp3S/GbdE0KoiQ+IGQOscREZuQUCXyOzDAAKCRCIGQOscREZ\r\n",
-                            "udgDAQCv3FJ3QWW5bRaGZAa0Ug6vASFdkvDMKoRwcoFnHPthjQEAiQ8skkIyE2GE\r\n",
-                            "PoLpAXiKpT+NU8S8+8dfvwutnb4dSwM=\r\n",
-                            "=3FYZ\r\n",
-                            "-----END PGP SIGNATURE-----\r\n",
-                           "\r\n",
-                           "--F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK--\r\n"));
+        assert_eq!(
+            String::from_utf8(part.formatted()).unwrap(),
+            concat!(
+                "Content-Type: multipart/signed; \r\n",
+                " boundary=\"0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\"; \r\n",
+                " protocol=\"application/pgp-signature\";",
+                " micalg=\"pgp-sha256\"\r\n",
+                "\r\n",
+                "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
+                "Content-Type: text/plain; charset=utf-8\r\n",
+                "Content-Transfer-Encoding: 7bit\r\n",
+                "\r\n",
+                "Test email for signature\r\n",
+                "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
+                "Content-Type: application/pgp-signature; name=\"signature.asc\"\r\n",
+                "Content-Disposition: attachment; filename=\"signature.asc\"\r\n",
+                "Content-Transfer-Encoding: 7bit\r\n",
+                "\r\n",
+                "-----BEGIN PGP SIGNATURE-----\r\n",
+                "\r\n",
+                "iHUEARYIAB0WIQTNsp3S/GbdE0KoiQ+IGQOscREZuQUCXyOzDAAKCRCIGQOscREZ\r\n",
+                "udgDAQCv3FJ3QWW5bRaGZAa0Ug6vASFdkvDMKoRwcoFnHPthjQEAiQ8skkIyE2GE\r\n",
+                "PoLpAXiKpT+NU8S8+8dfvwutnb4dSwM=\r\n",
+                "=3FYZ\r\n",
+                "-----END PGP SIGNATURE-----\r\n",
+                "\r\n",
+                "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1--\r\n"
+            )
+        );
     }
 
     #[test]
     fn multi_part_alternative() {
         let part = MultiPart::alternative()
-            .boundary("F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK")
-            .part(Part::Single(SinglePart::builder()
-                             .header(header::ContentType("text/plain; charset=utf8".parse().unwrap()))
-                             .header(header::ContentTransferEncoding::Binary)
-                             .body(String::from("Текст письма в уникоде"))))
+            .boundary("0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1")
             .singlepart(SinglePart::builder()
-                             .header(header::ContentType("text/html; charset=utf8".parse().unwrap()))
+                             .header(header::ContentType::TEXT_PLAIN)
+                             .header(header::ContentTransferEncoding::Binary)
+                             .body(String::from("Текст письма в уникоде")))
+            .singlepart(SinglePart::builder()
+                             .header(header::ContentType::TEXT_HTML)
                              .header(header::ContentTransferEncoding::Binary)
                              .body(String::from("<p>Текст <em>письма</em> в <a href=\"https://ru.wikipedia.org/wiki/Юникод\">уникоде</a><p>")));
 
         assert_eq!(String::from_utf8(part.formatted()).unwrap(),
-                   concat!("Content-Type: multipart/alternative;",
-                           " boundary=\"F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK\"\r\n",
+                   concat!("Content-Type: multipart/alternative; \r\n",
+                           " boundary=\"0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\"\r\n",
                            "\r\n",
-                           "--F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK\r\n",
-                           "Content-Type: text/plain; charset=utf8\r\n",
+                           "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
+                           "Content-Type: text/plain; charset=utf-8\r\n",
                            "Content-Transfer-Encoding: binary\r\n",
                            "\r\n",
                            "Текст письма в уникоде\r\n",
-                           "--F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK\r\n",
-                           "Content-Type: text/html; charset=utf8\r\n",
+                           "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
+                           "Content-Type: text/html; charset=utf-8\r\n",
                            "Content-Transfer-Encoding: binary\r\n",
                            "\r\n",
                            "<p>Текст <em>письма</em> в <a href=\"https://ru.wikipedia.org/wiki/Юникод\">уникоде</a><p>\r\n",
-                           "--F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK--\r\n"));
+                           "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1--\r\n"));
     }
 
     #[test]
     fn multi_part_mixed_related() {
         let part = MultiPart::mixed()
-            .boundary("F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK")
+            .boundary("0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1")
             .multipart(MultiPart::related()
-                            .boundary("E912L4JH3loAAAAAFu/33Gx7PEoTMmhGaxG3FlbVMQHctj96q4nHvBM+7DTtXo/im8gh")
+                            .boundary("0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1")
                             .singlepart(SinglePart::builder()
-                                             .header(header::ContentType("text/html; charset=utf8".parse().unwrap()))
+                                             .header(header::ContentType::TEXT_HTML)
                                              .header(header::ContentTransferEncoding::Binary)
                                              .body(String::from("<p>Текст <em>письма</em> в <a href=\"https://ru.wikipedia.org/wiki/Юникод\">уникоде</a><p>")))
                             .singlepart(SinglePart::builder()
-                                             .header(header::ContentType("image/png".parse().unwrap()))
-                                             .header(header::ContentLocation("/image.png".into()))
+                                             .header(header::ContentType::parse("image/png").unwrap())
+                                             .header(header::ContentLocation::from(String::from("/image.png")))
                                              .header(header::ContentTransferEncoding::Base64)
                                              .body(String::from("1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"))))
             .singlepart(SinglePart::builder()
-                             .header(header::ContentType("text/plain; charset=utf8".parse().unwrap()))
-                             .header(header::ContentDisposition {
-                                 disposition: header::DispositionType::Attachment,
-                                 parameters: vec![header::DispositionParam::Filename(header::Charset::Ext("utf-8".into()), None, "example.c".into())]
-                             })
+                             .header(header::ContentType::TEXT_PLAIN)
+                             .header(header::ContentDisposition::attachment("example.c"))
                              .header(header::ContentTransferEncoding::Binary)
                              .body(String::from("int main() { return 0; }")));
 
         assert_eq!(String::from_utf8(part.formatted()).unwrap(),
-                   concat!("Content-Type: multipart/mixed;",
-                           " boundary=\"F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK\"\r\n",
+                   concat!("Content-Type: multipart/mixed; \r\n",
+                           " boundary=\"0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\"\r\n",
                            "\r\n",
-                           "--F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK\r\n",
-                           "Content-Type: multipart/related;",
-                           " boundary=\"E912L4JH3loAAAAAFu/33Gx7PEoTMmhGaxG3FlbVMQHctj96q4nHvBM+7DTtXo/im8gh\"\r\n",
+                           "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
+                           "Content-Type: multipart/related; \r\n",
+                           " boundary=\"0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\"\r\n",
                            "\r\n",
-                           "--E912L4JH3loAAAAAFu/33Gx7PEoTMmhGaxG3FlbVMQHctj96q4nHvBM+7DTtXo/im8gh\r\n",
-                           "Content-Type: text/html; charset=utf8\r\n",
+                           "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
+                           "Content-Type: text/html; charset=utf-8\r\n",
                            "Content-Transfer-Encoding: binary\r\n",
                            "\r\n",
                            "<p>Текст <em>письма</em> в <a href=\"https://ru.wikipedia.org/wiki/Юникод\">уникоде</a><p>\r\n",
-                           "--E912L4JH3loAAAAAFu/33Gx7PEoTMmhGaxG3FlbVMQHctj96q4nHvBM+7DTtXo/im8gh\r\n",
+                           "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
                            "Content-Type: image/png\r\n",
                            "Content-Location: /image.png\r\n",
                            "Content-Transfer-Encoding: base64\r\n",
@@ -716,14 +680,14 @@ mod test {
                            "MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3\r\n",
                            "ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0\r\n",
                            "NTY3ODkwMTIzNDU2Nzg5MA==\r\n",
-                           "--E912L4JH3loAAAAAFu/33Gx7PEoTMmhGaxG3FlbVMQHctj96q4nHvBM+7DTtXo/im8gh--\r\n",
-                           "--F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK\r\n",
-                           "Content-Type: text/plain; charset=utf8\r\n",
+                           "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1--\r\n",
+                           "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
+                           "Content-Type: text/plain; charset=utf-8\r\n",
                            "Content-Disposition: attachment; filename=\"example.c\"\r\n",
                            "Content-Transfer-Encoding: binary\r\n",
                            "\r\n",
                            "int main() { return 0; }\r\n",
-                           "--F2mTKN843loAAAAA8porEdAjCKhArPxGeahYoZYSftse1GT/84tup+O0bs8eueVuAlMK--\r\n"));
+                           "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1--\r\n"));
     }
 
     #[test]

src/message/mod.rs

@@ -63,7 +63,7 @@
 //!
 //! ```rust
 //! # use std::error::Error;
-//! use lettre::message::{header, Message, MultiPart, Part, SinglePart};
+//! use lettre::message::{header, Message, MultiPart, SinglePart};
 //!
 //! # fn main() -> Result<(), Box<dyn Error>> {
 //! let m = Message::builder()
@@ -71,21 +71,10 @@
 //!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
 //!     .to("Hei <hei@domain.tld>".parse()?)
 //!     .subject("Happy new year")
-//!     .multipart(
-//!         MultiPart::alternative()
-//!             .singlepart(
-//!                 SinglePart::builder()
-//!                     .header(header::ContentType("text/plain; charset=utf8".parse()?))
-//!                     .body(String::from("Hello, world! :)")),
-//!             )
-//!             .singlepart(
-//!                 SinglePart::builder()
-//!                     .header(header::ContentType("text/html; charset=utf8".parse()?))
-//!                     .body(String::from(
-//!                         "<p><b>Hello</b>, <i>world</i>! <img src=\"cid:123\"></p>",
-//!                     )),
-//!             ),
-//!     )?;
+//!     .multipart(MultiPart::alternative_plain_html(
+//!         String::from("Hello, world! :)"),
+//!         String::from("<p><b>Hello</b>, <i>world</i>! <img src=\"cid:123\"></p>"),
+//!     ))?;
 //! # Ok(())
 //! # }
 //! ```
@@ -124,7 +113,7 @@
 //!
 //! ```rust
 //! # use std::error::Error;
-//! use lettre::message::{header, Body, Message, MultiPart, Part, SinglePart};
+//! use lettre::message::{header, Attachment, Body, Message, MultiPart, SinglePart};
 //! use std::fs;
 //!
 //! # fn main() -> Result<(), Box<dyn Error>> {
@@ -144,47 +133,22 @@
 //!         MultiPart::mixed()
 //!             .multipart(
 //!                 MultiPart::alternative()
-//!                     .singlepart(
-//!                         SinglePart::builder()
-//!                             .header(header::ContentType("text/plain; charset=utf8".parse()?))
-//!                             .body(String::from("Hello, world! :)")),
-//!                     )
+//!                     .singlepart(SinglePart::plain(String::from("Hello, world! :)")))
 //!                     .multipart(
 //!                         MultiPart::related()
+//!                             .singlepart(SinglePart::html(String::from(
+//!                                 "<p><b>Hello</b>, <i>world</i>! <img src=cid:123></p>",
+//!                             )))
 //!                             .singlepart(
-//!                                 SinglePart::builder()
-//!                                     .header(header::ContentType(
-//!                                         "text/html; charset=utf8".parse()?,
-//!                                     ))
-//!                                     .body(String::from(
-//!                                         "<p><b>Hello</b>, <i>world</i>! <img src=cid:123></p>",
-//!                                     )),
-//!                             )
-//!                             .singlepart(
-//!                                 SinglePart::builder()
-//!                                     .header(header::ContentType("image/png".parse()?))
-//!                                     .header(header::ContentDisposition {
-//!                                         disposition: header::DispositionType::Inline,
-//!                                         parameters: vec![],
-//!                                     })
-//!                                     .header(header::ContentId("<123>".into()))
-//!                                     .body(image_body),
+//!                                 Attachment::new_inline(String::from("123"))
+//!                                     .body(image_body, "image/png".parse().unwrap()),
 //!                             ),
 //!                     ),
 //!             )
-//!             .singlepart(
-//!                 SinglePart::builder()
-//!                     .header(header::ContentType("text/plain; charset=utf8".parse()?))
-//!                     .header(header::ContentDisposition {
-//!                         disposition: header::DispositionType::Attachment,
-//!                         parameters: vec![header::DispositionParam::Filename(
-//!                             header::Charset::Ext("utf-8".into()),
-//!                             None,
-//!                             "example.rs".as_bytes().into(),
-//!                         )],
-//!                     })
-//!                     .body(String::from("fn main() { println!(\"Hello, World!\") }")),
-//!             ),
+//!             .singlepart(Attachment::new(String::from("example.rs")).body(
+//!                 String::from("fn main() { println!(\"Hello, World!\") }"),
+//!                 "text/plain".parse().unwrap(),
+//!             )),
 //!     )?;
 //! # Ok(())
 //! # }
@@ -238,25 +202,22 @@
 //! ```
 //! </details>
 
+use std::{convert::TryFrom, io::Write, iter, time::SystemTime};
+
+pub use attachment::Attachment;
 pub use body::{Body, IntoBody, MaybeString};
 pub use mailbox::*;
 pub use mimebody::*;
 
-pub use mime;
-
+mod attachment;
 mod body;
 pub mod header;
 mod mailbox;
 mod mimebody;
-mod utf8_b;
-
-use std::{convert::TryFrom, time::SystemTime};
-
-use uuid::Uuid;
 
 use crate::{
     address::Envelope,
-    message::header::{ContentTransferEncoding, EmailDate, Header, Headers, MailboxesHeader},
+    message::header::{ContentTransferEncoding, Header, Headers, MailboxesHeader},
     Error as EmailError,
 };
 
@@ -291,37 +252,40 @@ impl MessageBuilder {
     }
 
     /// Add mailbox to header
-    pub fn mailbox<H: Header + MailboxesHeader>(mut self, header: H) -> Self {
-        if self.headers.has::<H>() {
-            self.headers.get_mut::<H>().unwrap().join_mailboxes(header);
-            self
-        } else {
-            self.header(header)
+    pub fn mailbox<H: Header + MailboxesHeader>(self, header: H) -> Self {
+        match self.headers.get::<H>() {
+            Some(mut header_) => {
+                header_.join_mailboxes(header);
+                self.header(header_)
+            }
+            None => self.header(header),
         }
     }
 
     /// Add `Date` header to message
     ///
-    /// Shortcut for `self.header(header::Date(date))`.
-    pub fn date(self, date: EmailDate) -> Self {
-        self.header(header::Date(date))
+    /// Shortcut for `self.header(header::Date::new(st))`.
+    pub fn date(self, st: SystemTime) -> Self {
+        self.header(header::Date::new(st))
     }
 
     /// Set `Date` header using current date/time
     ///
-    /// Shortcut for `self.date(SystemTime::now())`.
+    /// Shortcut for `self.date(SystemTime::now())`, it is automatically inserted
+    /// if no date has been provided.
     pub fn date_now(self) -> Self {
-        self.date(SystemTime::now().into())
+        self.date(SystemTime::now())
     }
 
     /// Set `Subject` header to message
     ///
     /// Shortcut for `self.header(header::Subject(subject.into()))`.
     pub fn subject<S: Into<String>>(self, subject: S) -> Self {
-        self.header(header::Subject(subject.into()))
+        let s: String = subject.into();
+        self.header(header::Subject::from(s))
     }
 
-    /// Set `Mime-Version` header to 1.0
+    /// Set `MIME-Version` header to 1.0
     ///
     /// Shortcut for `self.header(header::MIME_VERSION_1_0)`.
     ///
@@ -336,7 +300,7 @@ impl MessageBuilder {
     ///
     /// Shortcut for `self.header(header::Sender(mbox))`.
     pub fn sender(self, mbox: Mailbox) -> Self {
-        self.header(header::Sender(mbox))
+        self.header(header::Sender::from(mbox))
     }
 
     /// Set or add mailbox to `From` header
@@ -345,7 +309,7 @@ impl MessageBuilder {
     ///
     /// Shortcut for `self.mailbox(header::From(mbox))`.
     pub fn from(self, mbox: Mailbox) -> Self {
-        self.mailbox(header::From(mbox.into()))
+        self.mailbox(header::From::from(Mailboxes::from(mbox)))
     }
 
     /// Set or add mailbox to `ReplyTo` header
@@ -381,16 +345,16 @@ impl MessageBuilder {
     /// Set or add message id to [`In-Reply-To`
     /// header](https://tools.ietf.org/html/rfc5322#section-3.6.4)
     pub fn in_reply_to(self, id: String) -> Self {
-        self.header(header::InReplyTo(id))
+        self.header(header::InReplyTo::from(id))
     }
 
     /// Set or add message id to [`References`
     /// header](https://tools.ietf.org/html/rfc5322#section-3.6.4)
     pub fn references(self, id: String) -> Self {
-        self.header(header::References(id))
+        self.header(header::References::from(id))
     }
 
-    /// Set [Message-Id
+    /// Set [Message-ID
     /// header](https://tools.ietf.org/html/rfc5322#section-3.6.4)
     ///
     /// Should generally be inserted by the mail relay.
@@ -399,7 +363,7 @@ impl MessageBuilder {
     /// `<UUID@HOSTNAME>`.
     pub fn message_id(self, id: Option<String>) -> Self {
         match id {
-            Some(i) => self.header(header::MessageId(i)),
+            Some(i) => self.header(header::MessageId::from(i)),
             None => {
                 #[cfg(feature = "hostname")]
                 let hostname = hostname::get()
@@ -409,9 +373,9 @@ impl MessageBuilder {
                 #[cfg(not(feature = "hostname"))]
                 let hostname = DEFAULT_MESSAGE_ID_DOMAIN.to_string();
 
-                self.header(header::MessageId(
+                self.header(header::MessageId::from(
                     // https://tools.ietf.org/html/rfc5322#section-3.6.4
-                    format!("<{}@{}>", Uuid::new_v4(), hostname),
+                    format!("<{}@{}>", make_message_id(), hostname),
                 ))
             }
         }
@@ -420,7 +384,7 @@ impl MessageBuilder {
     /// Set [User-Agent
     /// header](https://tools.ietf.org/html/draft-melnikov-email-user-agent-004)
     pub fn user_agent(self, id: String) -> Self {
-        self.header(header::UserAgent(id))
+        self.header(header::UserAgent::from(id))
     }
 
     /// Force specific envelope (by default it is derived from headers)
@@ -446,7 +410,7 @@ impl MessageBuilder {
         // Fail is missing correct originator (Sender or From)
         match res.headers.get::<header::From>() {
             Some(header::From(f)) => {
-                let from: Vec<Mailbox> = f.clone().into();
+                let from: Vec<Mailbox> = f.into();
                 if from.len() > 1 && res.headers.get::<header::Sender>().is_none() {
                     return Err(EmailError::TooManyFrom);
                 }
@@ -473,7 +437,7 @@ impl MessageBuilder {
     /// `Content-Transfer-Encoding`, based on the most efficient and valid encoding
     /// for `body`.
     pub fn body<T: IntoBody>(mut self, body: T) -> Result<Message, EmailError> {
-        let maybe_encoding = self.headers.get::<ContentTransferEncoding>().copied();
+        let maybe_encoding = self.headers.get::<ContentTransferEncoding>();
         let body = body.into_body(maybe_encoding);
 
         self.headers.set(body.encoding());
@@ -532,7 +496,8 @@ impl Message {
 
 impl EmailFormat for Message {
     fn format(&self, out: &mut Vec<u8>) {
-        out.extend_from_slice(self.headers.to_string().as_bytes());
+        write!(out, "{}", self.headers)
+            .expect("A Write implementation panicked while formatting headers");
 
         match &self.body {
             MessageBody::Mime(p) => p.format(out),
@@ -550,9 +515,17 @@ impl Default for MessageBuilder {
     }
 }
 
+/// Create a random message id.
+/// (Not cryptographically random)
+fn make_message_id() -> String {
+    iter::repeat_with(fastrand::alphanumeric).take(36).collect()
+}
+
 #[cfg(test)]
 mod test {
-    use crate::message::{header, mailbox::Mailbox, Message, MultiPart, SinglePart};
+    use std::time::{Duration, SystemTime};
+
+    use super::{header, mailbox::Mailbox, make_message_id, Message, MultiPart, SinglePart};
 
     #[test]
     fn email_missing_originator() {
@@ -581,7 +554,8 @@ mod test {
 
     #[test]
     fn email_message() {
-        let date = "Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap();
+        // Tue, 15 Nov 1994 08:12:31 GMT
+        let date = SystemTime::UNIX_EPOCH + Duration::from_secs(784887151);
 
         let email = Message::builder()
             .date(date)
@@ -595,14 +569,14 @@ mod test {
             .header(header::To(
                 vec!["Pony O.P. <pony@domain.tld>".parse().unwrap()].into(),
             ))
-            .header(header::Subject("яңа ел белән!".into()))
+            .header(header::Subject::from(String::from("яңа ел белән!")))
             .body(String::from("Happy new year!"))
             .unwrap();
 
         assert_eq!(
             String::from_utf8(email.formatted()).unwrap(),
             concat!(
-                "Date: Tue, 15 Nov 1994 08:12:31 GMT\r\n",
+                "Date: Tue, 15 Nov 1994 08:12:31 -0000\r\n",
                 "From: =?utf-8?b?0JrQsNC4?= <kayo@example.com>\r\n",
                 "To: Pony O.P. <pony@domain.tld>\r\n",
                 "Subject: =?utf-8?b?0Y/So9CwINC10Lsg0LHQtdC705nQvSE=?=\r\n",
@@ -615,7 +589,8 @@ mod test {
 
     #[test]
     fn email_with_png() {
-        let date = "Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap();
+        // Tue, 15 Nov 1994 08:12:31 GMT
+        let date = SystemTime::UNIX_EPOCH + Duration::from_secs(784887151);
         let img = std::fs::read("./docs/lettre.png").unwrap();
         let m = Message::builder()
             .date(date)
@@ -627,21 +602,16 @@ mod test {
                 MultiPart::related()
                     .singlepart(
                         SinglePart::builder()
-                            .header(header::ContentType(
-                                "text/html; charset=utf8".parse().unwrap(),
-                            ))
+                            .header(header::ContentType::TEXT_HTML)
                             .body(String::from(
                                 "<p><b>Hello</b>, <i>world</i>! <img src=cid:123></p>",
                             )),
                     )
                     .singlepart(
                         SinglePart::builder()
-                            .header(header::ContentType("image/png".parse().unwrap()))
-                            .header(header::ContentDisposition {
-                                disposition: header::DispositionType::Inline,
-                                parameters: vec![],
-                            })
-                            .header(header::ContentId("<123>".into()))
+                            .header(header::ContentType::parse("image/png").unwrap())
+                            .header(header::ContentDisposition::inline())
+                            .header(header::ContentId::from(String::from("<123>")))
                             .body(img),
                     ),
             )
@@ -652,11 +622,27 @@ mod test {
         let expected = String::from_utf8(file_expected).unwrap();
 
         for (i, line) in output.lines().zip(expected.lines()).enumerate() {
-            if i == 6 || i == 8 || i == 13 || i == 232 {
+            if i == 7 || i == 9 || i == 14 || i == 233 {
                 continue;
             }
 
             assert_eq!(line.0, line.1)
         }
     }
+
+    #[test]
+    fn test_make_message_id() {
+        let mut ids = std::collections::HashSet::with_capacity(10);
+        for _ in 0..1000 {
+            ids.insert(make_message_id());
+        }
+
+        // Ensure there are no duplicates
+        assert_eq!(1000, ids.len());
+
+        // Ensure correct length
+        for id in ids {
+            assert_eq!(36, id.len());
+        }
+    }
 }

src/message/utf8_b.rs

@@ -1,60 +0,0 @@
-// https://tools.ietf.org/html/rfc1522
-
-fn allowed_char(c: char) -> bool {
-    c >= 1 as char && c <= 9 as char
-        || c == 11 as char
-        || c == 12 as char
-        || c >= 14 as char && c <= 127 as char
-}
-
-pub fn encode(s: &str) -> String {
-    if s.chars().all(allowed_char) {
-        s.into()
-    } else {
-        format!("=?utf-8?b?{}?=", base64::encode(s))
-    }
-}
-
-pub fn decode(s: &str) -> Option<String> {
-    s.strip_prefix("=?utf-8?b?")
-        .and_then(|stripped| stripped.strip_suffix("?="))
-        .map_or_else(
-            || Some(s.into()),
-            |stripped| {
-                let decoded = base64::decode(stripped).ok()?;
-                let decoded = String::from_utf8(decoded).ok()?;
-                Some(decoded)
-            },
-        )
-}
-
-#[cfg(test)]
-mod test {
-    use super::{decode, encode};
-
-    #[test]
-    fn encode_ascii() {
-        assert_eq!(&encode("Kayo. ?"), "Kayo. ?");
-    }
-
-    #[test]
-    fn decode_ascii() {
-        assert_eq!(decode("Kayo. ?"), Some("Kayo. ?".into()));
-    }
-
-    #[test]
-    fn encode_utf8() {
-        assert_eq!(
-            &encode("Привет, мир!"),
-            "=?utf-8?b?0J/RgNC40LLQtdGCLCDQvNC40YAh?="
-        );
-    }
-
-    #[test]
-    fn decode_utf8() {
-        assert_eq!(
-            decode("=?utf-8?b?0J/RgNC40LLQtdGCLCDQvNC40YAh?="),
-            Some("Привет, мир!".into())
-        );
-    }
-}

src/transport/file/mod.rs

@@ -134,11 +134,11 @@
 
 pub use self::error::Error;
 use crate::{address::Envelope, Transport};
-#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+#[cfg(any(feature = "async-std1", feature = "tokio1"))]
 use crate::{AsyncTransport, Executor};
-#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+#[cfg(any(feature = "async-std1", feature = "tokio1"))]
 use async_trait::async_trait;
-#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+#[cfg(any(feature = "async-std1", feature = "tokio1"))]
 use std::marker::PhantomData;
 use std::{
     path::{Path, PathBuf},
@@ -163,11 +163,8 @@ pub struct FileTransport {
 /// Asynchronously writes the content and the envelope information to a file
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-#[cfg_attr(
-    docsrs,
-    doc(cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1")))
-)]
-#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+#[cfg_attr(docsrs, doc(cfg(any(feature = "tokio1", feature = "async-std1"))))]
+#[cfg(any(feature = "async-std1", feature = "tokio1"))]
 pub struct AsyncFileTransport<E: Executor> {
     inner: FileTransport,
     marker_: PhantomData<E>,
@@ -220,7 +217,7 @@ impl FileTransport {
     }
 }
 
-#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+#[cfg(any(feature = "async-std1", feature = "tokio1"))]
 impl<E> AsyncFileTransport<E>
 where
     E: Executor,
@@ -290,7 +287,7 @@ impl Transport for FileTransport {
     }
 }
 
-#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+#[cfg(any(feature = "async-std1", feature = "tokio1"))]
 #[async_trait]
 impl<E> AsyncTransport for AsyncFileTransport<E>
 where

src/transport/mod.rs

@@ -4,6 +4,27 @@
 //! for sending emails. It automatically manages the underlying resources and doesn't require any
 //! specific knowledge of email protocols in order to be used.
 //!
+//! ### Getting started
+//!
+//! Sending emails from your programs requires using an email relay, as client libraries are not
+//! designed to handle email delivery by themselves. Depending on your infrastructure, your relay
+//! could be:
+//!
+//! * a service from your Cloud or hosting provider
+//! * an email server ([MTA] for Mail Transfer Agent, like Postfix or Exchange), running either
+//! locally on your servers or accessible over the network
+//! * a dedicated external service, like Mailchimp, Mailgun, etc.
+//!
+//! In most cases, the best option is to:
+//!
+//! * Use the [`SMTP`] transport, with the [`relay`] builder (or one of its async counterparts)
+//!   with your server's hostname. They provide modern and secure defaults.
+//! * Use the [`credentials`] method of the builder to pass your credentials.
+//!
+//! These should be enough to safely cover most use cases.
+//!
+//! ### Available transports
+//!
 //! The following transports are available:
 //!
 //! | Module       | Protocol | Sync API              | Async API                  | Description                                             |
@@ -63,6 +84,11 @@
 //! # fn main() {}
 //! ```
 //!
+//! [MTA]: https://en.wikipedia.org/wiki/Message_transfer_agent
+//! [`SMTP`]: crate::transport::smtp
+//! [`relay`]: crate::SmtpTransport::relay
+//! [`starttls_relay`]: crate::SmtpTransport::starttls_relay
+//! [`credentials`]: crate::transport::smtp::SmtpTransportBuilder::credentials
 //! [`Message`]: crate::Message
 //! [`file`]: self::file
 //! [`SmtpTransport`]: crate::SmtpTransport
@@ -73,7 +99,7 @@
 //! [`AsyncFileTransport`]: crate::AsyncFileTransport
 //! [`StubTransport`]: crate::transport::stub::StubTransport
 
-#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+#[cfg(any(feature = "async-std1", feature = "tokio1"))]
 use async_trait::async_trait;
 
 use crate::Envelope;
@@ -110,11 +136,8 @@ pub trait Transport {
 }
 
 /// Async Transport method for emails
-#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
-#[cfg_attr(
-    docsrs,
-    doc(cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1")))
-)]
+#[cfg(any(feature = "tokio1", feature = "async-std1"))]
+#[cfg_attr(docsrs, doc(cfg(any(feature = "tokio1", feature = "async-std1"))))]
 #[async_trait]
 pub trait AsyncTransport {
     /// Response produced by the Transport

src/transport/sendmail/mod.rs

@@ -26,29 +26,6 @@
 //! # fn main() {}
 //! ```
 //!
-//! ## Async tokio 0.2 example
-//!
-//! ```rust,no_run
-//! # use std::error::Error;
-//! #
-//! # #[cfg(all(feature = "tokio02", feature = "sendmail-transport", feature = "builder"))]
-//! # async fn run() -> Result<(), Box<dyn Error>> {
-//! use lettre::{Message, AsyncTransport, Tokio02Executor, AsyncSendmailTransport, SendmailTransport};
-//!
-//! let email = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
-//!     .subject("Happy new year")
-//!     .body(String::from("Be happy!"))?;
-//!
-//! let sender = AsyncSendmailTransport::<Tokio02Executor>::new();
-//! let result = sender.send(email).await;
-//! assert!(result.is_ok());
-//! # Ok(())
-//! # }
-//! ```
-//!
 //! ## Async tokio 1.x example
 //!
 //! ```rust,no_run
@@ -98,16 +75,14 @@
 pub use self::error::Error;
 #[cfg(feature = "async-std1")]
 use crate::AsyncStd1Executor;
-#[cfg(feature = "tokio02")]
-use crate::Tokio02Executor;
 #[cfg(feature = "tokio1")]
 use crate::Tokio1Executor;
 use crate::{address::Envelope, Transport};
-#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+#[cfg(any(feature = "async-std1", feature = "tokio1"))]
 use crate::{AsyncTransport, Executor};
-#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+#[cfg(any(feature = "async-std1", feature = "tokio1"))]
 use async_trait::async_trait;
-#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+#[cfg(any(feature = "async-std1", feature = "tokio1"))]
 use std::marker::PhantomData;
 use std::{
     ffi::OsString,
@@ -130,11 +105,8 @@ pub struct SendmailTransport {
 /// Asynchronously sends emails using the `sendmail` command
 #[derive(Debug, Clone)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
-#[cfg_attr(
-    docsrs,
-    doc(cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1")))
-)]
+#[cfg(any(feature = "async-std1", feature = "tokio1"))]
+#[cfg_attr(docsrs, doc(cfg(any(feature = "tokio1", feature = "async-std1"))))]
 pub struct AsyncSendmailTransport<E: Executor> {
     inner: SendmailTransport,
     marker_: PhantomData<E>,
@@ -170,7 +142,7 @@ impl SendmailTransport {
     }
 }
 
-#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+#[cfg(any(feature = "async-std1", feature = "tokio1"))]
 impl<E> AsyncSendmailTransport<E>
 where
     E: Executor,
@@ -191,24 +163,6 @@ where
         }
     }
 
-    #[cfg(feature = "tokio02")]
-    fn tokio02_command(&self, envelope: &Envelope) -> tokio02_crate::process::Command {
-        use tokio02_crate::process::Command;
-
-        let mut c = Command::new(&self.inner.command);
-        c.kill_on_drop(true);
-        c.arg("-i");
-        if let Some(from) = envelope.from() {
-            c.arg("-f").arg(from);
-        }
-        c.arg("--")
-            .args(envelope.to())
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped());
-        c
-    }
-
     #[cfg(feature = "tokio1")]
     fn tokio1_command(&self, envelope: &Envelope) -> tokio1_crate::process::Command {
         use tokio1_crate::process::Command;
@@ -253,7 +207,7 @@ impl Default for SendmailTransport {
     }
 }
 
-#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+#[cfg(any(feature = "async-std1", feature = "tokio1"))]
 impl<E> Default for AsyncSendmailTransport<E>
 where
     E: Executor,
@@ -320,38 +274,6 @@ impl AsyncTransport for AsyncSendmailTransport<AsyncStd1Executor> {
     }
 }
 
-#[cfg(feature = "tokio02")]
-#[async_trait]
-impl AsyncTransport for AsyncSendmailTransport<Tokio02Executor> {
-    type Ok = ();
-    type Error = Error;
-
-    async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
-        use tokio02_crate::io::AsyncWriteExt;
-
-        let mut command = self.tokio02_command(envelope);
-
-        // Spawn the sendmail command
-        let mut process = command.spawn().map_err(error::client)?;
-
-        process
-            .stdin
-            .as_mut()
-            .unwrap()
-            .write_all(&email)
-            .await
-            .map_err(error::client)?;
-        let output = process.wait_with_output().await.map_err(error::client)?;
-
-        if output.status.success() {
-            Ok(())
-        } else {
-            let stderr = String::from_utf8(output.stderr).map_err(error::response)?;
-            Err(error::client(stderr))
-        }
-    }
-}
-
 #[cfg(feature = "tokio1")]
 #[async_trait]
 impl AsyncTransport for AsyncSendmailTransport<Tokio1Executor> {

src/transport/smtp/async_transport.rs

@@ -1,5 +1,7 @@
-use std::fmt::{self, Debug};
-use std::marker::PhantomData;
+use std::{
+    fmt::{self, Debug},
+    marker::PhantomData,
+};
 
 use async_trait::async_trait;
 
@@ -8,42 +10,19 @@ use super::{
 };
 #[cfg(feature = "async-std1")]
 use crate::AsyncStd1Executor;
-#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
+#[cfg(any(feature = "tokio1", feature = "async-std1"))]
 use crate::AsyncTransport;
-#[cfg(feature = "tokio02")]
-use crate::Tokio02Executor;
 #[cfg(feature = "tokio1")]
 use crate::Tokio1Executor;
 use crate::{Envelope, Executor};
 
 /// Asynchronously sends emails using the SMTP protocol
-#[cfg_attr(
-    docsrs,
-    doc(cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1")))
-)]
+#[cfg_attr(docsrs, doc(cfg(any(feature = "tokio1", feature = "async-std1"))))]
 pub struct AsyncSmtpTransport<E> {
     // TODO: pool
     inner: AsyncSmtpClient<E>,
 }
 
-#[cfg(feature = "tokio02")]
-#[async_trait]
-impl AsyncTransport for AsyncSmtpTransport<Tokio02Executor> {
-    type Ok = Response;
-    type Error = Error;
-
-    /// Sends an email
-    async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
-        let mut conn = self.inner.connection().await?;
-
-        let result = conn.send(envelope, email).await?;
-
-        conn.quit().await?;
-
-        Ok(result)
-    }
-}
-
 #[cfg(feature = "tokio1")]
 #[async_trait]
 impl AsyncTransport for AsyncSmtpTransport<Tokio1Executor> {
@@ -91,8 +70,6 @@ where
     /// Creates an encrypted transport over submissions port, using the provided domain
     /// to validate TLS certificates.
     #[cfg(any(
-        feature = "tokio02-native-tls",
-        feature = "tokio02-rustls-tls",
         feature = "tokio1-native-tls",
         feature = "tokio1-rustls-tls",
         feature = "async-std1-native-tls",
@@ -101,8 +78,6 @@ where
     #[cfg_attr(
         docsrs,
         doc(cfg(any(
-            feature = "tokio02-native-tls",
-            feature = "tokio02-rustls-tls",
             feature = "tokio1-native-tls",
             feature = "tokio1-rustls-tls",
             feature = "async-std1-rustls-tls"
@@ -130,8 +105,6 @@ where
     /// An error is returned if the connection can't be upgraded. No credentials
     /// or emails will be sent to the server, protecting from downgrade attacks.
     #[cfg(any(
-        feature = "tokio02-native-tls",
-        feature = "tokio02-rustls-tls",
         feature = "tokio1-native-tls",
         feature = "tokio1-rustls-tls",
         feature = "async-std1-native-tls",
@@ -140,8 +113,6 @@ where
     #[cfg_attr(
         docsrs,
         doc(cfg(any(
-            feature = "tokio02-native-tls",
-            feature = "tokio02-rustls-tls",
             feature = "tokio1-native-tls",
             feature = "tokio1-rustls-tls",
             feature = "async-std1-rustls-tls"
@@ -206,10 +177,7 @@ where
 /// Contains client configuration.
 /// Instances of this struct can be created using functions of [`AsyncSmtpTransport`].
 #[derive(Debug, Clone)]
-#[cfg_attr(
-    docsrs,
-    doc(cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1")))
-)]
+#[cfg_attr(docsrs, doc(cfg(any(feature = "tokio1", feature = "async-std1"))))]
 pub struct AsyncSmtpTransportBuilder {
     info: SmtpInfo,
 }
@@ -242,8 +210,6 @@ impl AsyncSmtpTransportBuilder {
 
     /// Set the TLS settings to use
     #[cfg(any(
-        feature = "tokio02-native-tls",
-        feature = "tokio02-rustls-tls",
         feature = "tokio1-native-tls",
         feature = "tokio1-rustls-tls",
         feature = "async-std1-native-tls",
@@ -252,8 +218,6 @@ impl AsyncSmtpTransportBuilder {
     #[cfg_attr(
         docsrs,
         doc(cfg(any(
-            feature = "tokio02-native-tls",
-            feature = "tokio02-rustls-tls",
             feature = "tokio1-native-tls",
             feature = "tokio1-rustls-tls",
             feature = "async-std1-rustls-tls"

src/transport/smtp/client/async_connection.rs

@@ -44,20 +44,6 @@ impl AsyncSmtpConnection {
         &self.server_info
     }
 
-    /// Connects to the configured server
-    ///
-    /// Sends EHLO and parses server information
-    #[cfg(feature = "tokio02")]
-    pub async fn connect_tokio02(
-        hostname: &str,
-        port: u16,
-        hello_name: &ClientId,
-        tls_parameters: Option<TlsParameters>,
-    ) -> Result<AsyncSmtpConnection, Error> {
-        let stream = AsyncNetworkStream::connect_tokio02(hostname, port, tls_parameters).await?;
-        Self::connect_impl(stream, hello_name).await
-    }
-
     /// Connects to the configured server
     ///
     /// Sends EHLO and parses server information

src/transport/smtp/client/async_net.rs

@@ -1,10 +1,5 @@
-#[cfg(any(
-    feature = "tokio02-rustls-tls",
-    feature = "tokio1-rustls-tls",
-    feature = "async-std1-rustls-tls"
-))]
-use std::sync::Arc;
 use std::{
+    mem,
     net::SocketAddr,
     pin::Pin,
     task::{Context, Poll},
@@ -14,35 +9,25 @@ use futures_io::{
     AsyncRead as FuturesAsyncRead, AsyncWrite as FuturesAsyncWrite, Error as IoError, ErrorKind,
     Result as IoResult,
 };
-#[cfg(feature = "tokio02")]
-use tokio02_crate::io::{AsyncRead as _, AsyncWrite as _};
 #[cfg(feature = "tokio1")]
 use tokio1_crate::io::{AsyncRead as _, AsyncWrite as _, ReadBuf as Tokio1ReadBuf};
 
 #[cfg(feature = "async-std1")]
 use async_std::net::TcpStream as AsyncStd1TcpStream;
-#[cfg(feature = "tokio02")]
-use tokio02_crate::net::TcpStream as Tokio02TcpStream;
 #[cfg(feature = "tokio1")]
 use tokio1_crate::net::TcpStream as Tokio1TcpStream;
 
 #[cfg(feature = "async-std1-native-tls")]
 use async_native_tls::TlsStream as AsyncStd1TlsStream;
-#[cfg(feature = "tokio02-native-tls")]
-use tokio02_native_tls_crate::TlsStream as Tokio02TlsStream;
 #[cfg(feature = "tokio1-native-tls")]
 use tokio1_native_tls_crate::TlsStream as Tokio1TlsStream;
 
 #[cfg(feature = "async-std1-rustls-tls")]
 use async_rustls::client::TlsStream as AsyncStd1RustlsTlsStream;
-#[cfg(feature = "tokio02-rustls-tls")]
-use tokio02_rustls::client::TlsStream as Tokio02RustlsTlsStream;
 #[cfg(feature = "tokio1-rustls-tls")]
 use tokio1_rustls::client::TlsStream as Tokio1RustlsTlsStream;
 
 #[cfg(any(
-    feature = "tokio02-native-tls",
-    feature = "tokio02-rustls-tls",
     feature = "tokio1-native-tls",
     feature = "tokio1-rustls-tls",
     feature = "async-std1-native-tls",
@@ -63,15 +48,6 @@ pub struct AsyncNetworkStream {
 #[allow(clippy::large_enum_variant)]
 #[allow(dead_code)]
 enum InnerAsyncNetworkStream {
-    /// Plain Tokio 0.2 TCP stream
-    #[cfg(feature = "tokio02")]
-    Tokio02Tcp(Tokio02TcpStream),
-    /// Encrypted Tokio 0.2 TCP stream
-    #[cfg(feature = "tokio02-native-tls")]
-    Tokio02NativeTls(Tokio02TlsStream<Tokio02TcpStream>),
-    /// Encrypted Tokio 0.2 TCP stream
-    #[cfg(feature = "tokio02-rustls-tls")]
-    Tokio02RustlsTls(Tokio02RustlsTlsStream<Tokio02TcpStream>),
     /// Plain Tokio 1.x TCP stream
     #[cfg(feature = "tokio1")]
     Tokio1Tcp(Tokio1TcpStream),
@@ -106,14 +82,6 @@ impl AsyncNetworkStream {
     /// Returns peer's address
     pub fn peer_addr(&self) -> IoResult<SocketAddr> {
         match self.inner {
-            #[cfg(feature = "tokio02")]
-            InnerAsyncNetworkStream::Tokio02Tcp(ref s) => s.peer_addr(),
-            #[cfg(feature = "tokio02-native-tls")]
-            InnerAsyncNetworkStream::Tokio02NativeTls(ref s) => {
-                s.get_ref().get_ref().get_ref().peer_addr()
-            }
-            #[cfg(feature = "tokio02-rustls-tls")]
-            InnerAsyncNetworkStream::Tokio02RustlsTls(ref s) => s.get_ref().0.peer_addr(),
             #[cfg(feature = "tokio1")]
             InnerAsyncNetworkStream::Tokio1Tcp(ref s) => s.peer_addr(),
             #[cfg(feature = "tokio1-native-tls")]
@@ -138,23 +106,6 @@ impl AsyncNetworkStream {
         }
     }
 
-    #[cfg(feature = "tokio02")]
-    pub async fn connect_tokio02(
-        hostname: &str,
-        port: u16,
-        tls_parameters: Option<TlsParameters>,
-    ) -> Result<AsyncNetworkStream, Error> {
-        let tcp_stream = Tokio02TcpStream::connect((hostname, port))
-            .await
-            .map_err(error::connection)?;
-
-        let mut stream = AsyncNetworkStream::new(InnerAsyncNetworkStream::Tokio02Tcp(tcp_stream));
-        if let Some(tls_parameters) = tls_parameters {
-            stream.upgrade_tls(tls_parameters).await?;
-        }
-        Ok(stream)
-    }
-
     #[cfg(feature = "tokio1")]
     pub async fn connect_tokio1(
         hostname: &str,
@@ -191,29 +142,6 @@ impl AsyncNetworkStream {
 
     pub async fn upgrade_tls(&mut self, tls_parameters: TlsParameters) -> Result<(), Error> {
         match &self.inner {
-            #[cfg(all(
-                feature = "tokio02",
-                not(any(feature = "tokio02-native-tls", feature = "tokio02-rustls-tls"))
-            ))]
-            InnerAsyncNetworkStream::Tokio02Tcp(_) => {
-                let _ = tls_parameters;
-                panic!("Trying to upgrade an AsyncNetworkStream without having enabled either the tokio02-native-tls or the tokio02-rustls-tls feature");
-            }
-
-            #[cfg(any(feature = "tokio02-native-tls", feature = "tokio02-rustls-tls"))]
-            InnerAsyncNetworkStream::Tokio02Tcp(_) => {
-                // get owned TcpStream
-                let tcp_stream = std::mem::replace(&mut self.inner, InnerAsyncNetworkStream::None);
-                let tcp_stream = match tcp_stream {
-                    InnerAsyncNetworkStream::Tokio02Tcp(tcp_stream) => tcp_stream,
-                    _ => unreachable!(),
-                };
-
-                self.inner = Self::upgrade_tokio02_tls(tcp_stream, tls_parameters)
-                    .await
-                    .map_err(error::connection)?;
-                Ok(())
-            }
             #[cfg(all(
                 feature = "tokio1",
                 not(any(feature = "tokio1-native-tls", feature = "tokio1-rustls-tls"))
@@ -226,7 +154,7 @@ impl AsyncNetworkStream {
             #[cfg(any(feature = "tokio1-native-tls", feature = "tokio1-rustls-tls"))]
             InnerAsyncNetworkStream::Tokio1Tcp(_) => {
                 // get owned TcpStream
-                let tcp_stream = std::mem::replace(&mut self.inner, InnerAsyncNetworkStream::None);
+                let tcp_stream = mem::replace(&mut self.inner, InnerAsyncNetworkStream::None);
                 let tcp_stream = match tcp_stream {
                     InnerAsyncNetworkStream::Tokio1Tcp(tcp_stream) => tcp_stream,
                     _ => unreachable!(),
@@ -249,7 +177,7 @@ impl AsyncNetworkStream {
             #[cfg(any(feature = "async-std1-native-tls", feature = "async-std1-rustls-tls"))]
             InnerAsyncNetworkStream::AsyncStd1Tcp(_) => {
                 // get owned TcpStream
-                let tcp_stream = std::mem::replace(&mut self.inner, InnerAsyncNetworkStream::None);
+                let tcp_stream = mem::replace(&mut self.inner, InnerAsyncNetworkStream::None);
                 let tcp_stream = match tcp_stream {
                     InnerAsyncNetworkStream::AsyncStd1Tcp(tcp_stream) => tcp_stream,
                     _ => unreachable!(),
@@ -264,62 +192,13 @@ impl AsyncNetworkStream {
         }
     }
 
-    #[allow(unused_variables)]
-    #[cfg(any(feature = "tokio02-native-tls", feature = "tokio02-rustls-tls"))]
-    async fn upgrade_tokio02_tls(
-        tcp_stream: Tokio02TcpStream,
-        mut tls_parameters: TlsParameters,
-    ) -> Result<InnerAsyncNetworkStream, Error> {
-        let domain = std::mem::take(&mut tls_parameters.domain);
-
-        match tls_parameters.connector {
-            #[cfg(feature = "native-tls")]
-            InnerTlsParameters::NativeTls(connector) => {
-                #[cfg(not(feature = "tokio02-native-tls"))]
-                panic!("built without the tokio02-native-tls feature");
-
-                #[cfg(feature = "tokio02-native-tls")]
-                return {
-                    use tokio02_native_tls_crate::TlsConnector;
-
-                    let connector = TlsConnector::from(connector);
-                    let stream = connector
-                        .connect(&domain, tcp_stream)
-                        .await
-                        .map_err(error::connection)?;
-                    Ok(InnerAsyncNetworkStream::Tokio02NativeTls(stream))
-                };
-            }
-            #[cfg(feature = "rustls-tls")]
-            InnerTlsParameters::RustlsTls(config) => {
-                #[cfg(not(feature = "tokio02-rustls-tls"))]
-                panic!("built without the tokio02-rustls-tls feature");
-
-                #[cfg(feature = "tokio02-rustls-tls")]
-                return {
-                    use tokio02_rustls::{webpki::DNSNameRef, TlsConnector};
-
-                    let domain =
-                        DNSNameRef::try_from_ascii_str(&domain).map_err(error::connection)?;
-
-                    let connector = TlsConnector::from(Arc::new(config));
-                    let stream = connector
-                        .connect(domain, tcp_stream)
-                        .await
-                        .map_err(error::connection)?;
-                    Ok(InnerAsyncNetworkStream::Tokio02RustlsTls(stream))
-                };
-            }
-        }
-    }
-
     #[allow(unused_variables)]
     #[cfg(any(feature = "tokio1-native-tls", feature = "tokio1-rustls-tls"))]
     async fn upgrade_tokio1_tls(
         tcp_stream: Tokio1TcpStream,
         mut tls_parameters: TlsParameters,
     ) -> Result<InnerAsyncNetworkStream, Error> {
-        let domain = std::mem::take(&mut tls_parameters.domain);
+        let domain = mem::take(&mut tls_parameters.domain);
 
         match tls_parameters.connector {
             #[cfg(feature = "native-tls")]
@@ -351,7 +230,7 @@ impl AsyncNetworkStream {
                     let domain =
                         DNSNameRef::try_from_ascii_str(&domain).map_err(error::connection)?;
 
-                    let connector = TlsConnector::from(Arc::new(config));
+                    let connector = TlsConnector::from(config);
                     let stream = connector
                         .connect(domain, tcp_stream)
                         .await
@@ -368,7 +247,7 @@ impl AsyncNetworkStream {
         tcp_stream: AsyncStd1TcpStream,
         mut tls_parameters: TlsParameters,
     ) -> Result<InnerAsyncNetworkStream, Error> {
-        let domain = std::mem::take(&mut tls_parameters.domain);
+        let domain = mem::take(&mut tls_parameters.domain);
 
         match tls_parameters.connector {
             #[cfg(feature = "native-tls")]
@@ -403,7 +282,7 @@ impl AsyncNetworkStream {
                     let domain =
                         DNSNameRef::try_from_ascii_str(&domain).map_err(error::connection)?;
 
-                    let connector = TlsConnector::from(Arc::new(config));
+                    let connector = TlsConnector::from(config);
                     let stream = connector
                         .connect(domain, tcp_stream)
                         .await
@@ -416,12 +295,6 @@ impl AsyncNetworkStream {
 
     pub fn is_encrypted(&self) -> bool {
         match self.inner {
-            #[cfg(feature = "tokio02")]
-            InnerAsyncNetworkStream::Tokio02Tcp(_) => false,
-            #[cfg(feature = "tokio02-native-tls")]
-            InnerAsyncNetworkStream::Tokio02NativeTls(_) => true,
-            #[cfg(feature = "tokio02-rustls-tls")]
-            InnerAsyncNetworkStream::Tokio02RustlsTls(_) => true,
             #[cfg(feature = "tokio1")]
             InnerAsyncNetworkStream::Tokio1Tcp(_) => false,
             #[cfg(feature = "tokio1-native-tls")]
@@ -446,12 +319,6 @@ impl FuturesAsyncRead for AsyncNetworkStream {
         buf: &mut [u8],
     ) -> Poll<IoResult<usize>> {
         match self.inner {
-            #[cfg(feature = "tokio02")]
-            InnerAsyncNetworkStream::Tokio02Tcp(ref mut s) => Pin::new(s).poll_read(cx, buf),
-            #[cfg(feature = "tokio02-native-tls")]
-            InnerAsyncNetworkStream::Tokio02NativeTls(ref mut s) => Pin::new(s).poll_read(cx, buf),
-            #[cfg(feature = "tokio02-rustls-tls")]
-            InnerAsyncNetworkStream::Tokio02RustlsTls(ref mut s) => Pin::new(s).poll_read(cx, buf),
             #[cfg(feature = "tokio1")]
             InnerAsyncNetworkStream::Tokio1Tcp(ref mut s) => {
                 let mut b = Tokio1ReadBuf::new(buf);
@@ -504,12 +371,6 @@ impl FuturesAsyncWrite for AsyncNetworkStream {
         buf: &[u8],
     ) -> Poll<IoResult<usize>> {
         match self.inner {
-            #[cfg(feature = "tokio02")]
-            InnerAsyncNetworkStream::Tokio02Tcp(ref mut s) => Pin::new(s).poll_write(cx, buf),
-            #[cfg(feature = "tokio02-native-tls")]
-            InnerAsyncNetworkStream::Tokio02NativeTls(ref mut s) => Pin::new(s).poll_write(cx, buf),
-            #[cfg(feature = "tokio02-rustls-tls")]
-            InnerAsyncNetworkStream::Tokio02RustlsTls(ref mut s) => Pin::new(s).poll_write(cx, buf),
             #[cfg(feature = "tokio1")]
             InnerAsyncNetworkStream::Tokio1Tcp(ref mut s) => Pin::new(s).poll_write(cx, buf),
             #[cfg(feature = "tokio1-native-tls")]
@@ -535,12 +396,6 @@ impl FuturesAsyncWrite for AsyncNetworkStream {
 
     fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<IoResult<()>> {
         match self.inner {
-            #[cfg(feature = "tokio02")]
-            InnerAsyncNetworkStream::Tokio02Tcp(ref mut s) => Pin::new(s).poll_flush(cx),
-            #[cfg(feature = "tokio02-native-tls")]
-            InnerAsyncNetworkStream::Tokio02NativeTls(ref mut s) => Pin::new(s).poll_flush(cx),
-            #[cfg(feature = "tokio02-rustls-tls")]
-            InnerAsyncNetworkStream::Tokio02RustlsTls(ref mut s) => Pin::new(s).poll_flush(cx),
             #[cfg(feature = "tokio1")]
             InnerAsyncNetworkStream::Tokio1Tcp(ref mut s) => Pin::new(s).poll_flush(cx),
             #[cfg(feature = "tokio1-native-tls")]
@@ -562,12 +417,6 @@ impl FuturesAsyncWrite for AsyncNetworkStream {
 
     fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<IoResult<()>> {
         match self.inner {
-            #[cfg(feature = "tokio02")]
-            InnerAsyncNetworkStream::Tokio02Tcp(ref mut s) => Pin::new(s).poll_shutdown(cx),
-            #[cfg(feature = "tokio02-native-tls")]
-            InnerAsyncNetworkStream::Tokio02NativeTls(ref mut s) => Pin::new(s).poll_shutdown(cx),
-            #[cfg(feature = "tokio02-rustls-tls")]
-            InnerAsyncNetworkStream::Tokio02RustlsTls(ref mut s) => Pin::new(s).poll_shutdown(cx),
             #[cfg(feature = "tokio1")]
             InnerAsyncNetworkStream::Tokio1Tcp(ref mut s) => Pin::new(s).poll_shutdown(cx),
             #[cfg(feature = "tokio1-native-tls")]

src/transport/smtp/client/mock.rs

@@ -1,122 +0,0 @@
-#![allow(missing_docs)]
-// Comes from https://github.com/inre/rust-mq/blob/master/netopt
-
-use std::{
-    io::{self, Cursor, Read, Write},
-    sync::{Arc, Mutex},
-};
-
-pub type MockCursor = Cursor<Vec<u8>>;
-
-#[derive(Clone, Debug)]
-pub struct MockStream {
-    reader: Arc<Mutex<MockCursor>>,
-    writer: Arc<Mutex<MockCursor>>,
-}
-
-impl Default for MockStream {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl MockStream {
-    pub fn new() -> MockStream {
-        MockStream {
-            reader: Arc::new(Mutex::new(MockCursor::new(Vec::new()))),
-            writer: Arc::new(Mutex::new(MockCursor::new(Vec::new()))),
-        }
-    }
-
-    pub fn with_vec(vec: Vec<u8>) -> MockStream {
-        MockStream {
-            reader: Arc::new(Mutex::new(MockCursor::new(vec))),
-            writer: Arc::new(Mutex::new(MockCursor::new(Vec::new()))),
-        }
-    }
-
-    pub fn take_vec(&mut self) -> Vec<u8> {
-        let mut cursor = self.writer.lock().unwrap();
-        let vec = cursor.get_ref().to_vec();
-        cursor.set_position(0);
-        cursor.get_mut().clear();
-        vec
-    }
-
-    pub fn next_vec(&mut self, vec: &[u8]) {
-        let mut cursor = self.reader.lock().unwrap();
-        cursor.set_position(0);
-        cursor.get_mut().clear();
-        cursor.get_mut().extend_from_slice(vec);
-    }
-
-    pub fn swap(&mut self) {
-        let mut cur_write = self.writer.lock().unwrap();
-        let mut cur_read = self.reader.lock().unwrap();
-        let vec_write = cur_write.get_ref().to_vec();
-        let vec_read = cur_read.get_ref().to_vec();
-        cur_write.set_position(0);
-        cur_read.set_position(0);
-        cur_write.get_mut().clear();
-        cur_read.get_mut().clear();
-        // swap cursors
-        cur_read.get_mut().extend_from_slice(vec_write.as_slice());
-        cur_write.get_mut().extend_from_slice(vec_read.as_slice());
-    }
-}
-
-impl Write for MockStream {
-    fn write(&mut self, msg: &[u8]) -> io::Result<usize> {
-        self.writer.lock().unwrap().write(msg)
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        self.writer.lock().unwrap().flush()
-    }
-}
-
-impl Read for MockStream {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.reader.lock().unwrap().read(buf)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::MockStream;
-    use std::io::{Read, Write};
-
-    #[test]
-    fn write_take_test() {
-        let mut mock = MockStream::new();
-        // write to mock stream
-        mock.write_all(&[1, 2, 3]).unwrap();
-        assert_eq!(mock.take_vec(), vec![1, 2, 3]);
-    }
-
-    #[test]
-    fn read_with_vec_test() {
-        let mut mock = MockStream::with_vec(vec![4, 5]);
-        let mut vec = Vec::new();
-        mock.read_to_end(&mut vec).unwrap();
-        assert_eq!(vec, vec![4, 5]);
-    }
-
-    #[test]
-    fn clone_test() {
-        let mut mock = MockStream::new();
-        let mut cloned = mock.clone();
-        mock.write_all(&[6, 7]).unwrap();
-        assert_eq!(cloned.take_vec(), vec![6, 7]);
-    }
-
-    #[test]
-    fn swap_test() {
-        let mut mock = MockStream::new();
-        let mut vec = Vec::new();
-        mock.write_all(&[8, 9, 10]).unwrap();
-        mock.swap();
-        mock.read_to_end(&mut vec).unwrap();
-        assert_eq!(vec, vec![8, 9, 10]);
-    }
-}

src/transport/smtp/client/mod.rs

@@ -27,25 +27,23 @@
 #[cfg(feature = "serde")]
 use std::fmt::Debug;
 
-#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
+#[cfg(any(feature = "tokio1", feature = "async-std1"))]
 pub(crate) use self::async_connection::AsyncSmtpConnection;
-#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
+#[cfg(any(feature = "tokio1", feature = "async-std1"))]
 pub(crate) use self::async_net::AsyncNetworkStream;
 use self::net::NetworkStream;
 #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
 pub(super) use self::tls::InnerTlsParameters;
 pub use self::{
     connection::SmtpConnection,
-    mock::MockStream,
     tls::{Certificate, Tls, TlsParameters, TlsParametersBuilder},
 };
 
-#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
+#[cfg(any(feature = "tokio1", feature = "async-std1"))]
 mod async_connection;
-#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
+#[cfg(any(feature = "tokio1", feature = "async-std1"))]
 mod async_net;
 mod connection;
-mod mock;
 mod net;
 mod tls;
 

src/transport/smtp/client/net.rs

@@ -1,7 +1,6 @@
-#[cfg(feature = "rustls-tls")]
-use std::sync::Arc;
 use std::{
     io::{self, Read, Write},
+    mem,
     net::{Ipv4Addr, Shutdown, SocketAddr, SocketAddrV4, TcpStream, ToSocketAddrs},
     time::Duration,
 };
@@ -14,7 +13,7 @@ use rustls::{ClientSession, StreamOwned};
 
 #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
 use super::InnerTlsParameters;
-use super::{MockStream, TlsParameters};
+use super::TlsParameters;
 use crate::transport::smtp::{error, Error};
 
 /// A network stream
@@ -35,17 +34,17 @@ enum InnerNetworkStream {
     /// Encrypted TCP stream
     #[cfg(feature = "rustls-tls")]
     RustlsTls(StreamOwned<ClientSession, TcpStream>),
-    /// Mock stream
-    Mock(MockStream),
+    /// Can't be built
+    None,
 }
 
 impl NetworkStream {
     fn new(inner: InnerNetworkStream) -> Self {
-        NetworkStream { inner }
-    }
+        if let InnerNetworkStream::None = inner {
+            debug_assert!(false, "InnerNetworkStream::None must never be built");
+        }
 
-    pub fn new_mock(mock: MockStream) -> Self {
-        Self::new(InnerNetworkStream::Mock(mock))
+        NetworkStream { inner }
     }
 
     /// Returns peer's address
@@ -56,10 +55,13 @@ impl NetworkStream {
             InnerNetworkStream::NativeTls(ref s) => s.get_ref().peer_addr(),
             #[cfg(feature = "rustls-tls")]
             InnerNetworkStream::RustlsTls(ref s) => s.get_ref().peer_addr(),
-            InnerNetworkStream::Mock(_) => Ok(SocketAddr::V4(SocketAddrV4::new(
-                Ipv4Addr::new(127, 0, 0, 1),
-                80,
-            ))),
+            InnerNetworkStream::None => {
+                debug_assert!(false, "InnerNetworkStream::None must never be built");
+                Ok(SocketAddr::V4(SocketAddrV4::new(
+                    Ipv4Addr::new(127, 0, 0, 1),
+                    80,
+                )))
+            }
         }
     }
 
@@ -71,7 +73,10 @@ impl NetworkStream {
             InnerNetworkStream::NativeTls(ref s) => s.get_ref().shutdown(how),
             #[cfg(feature = "rustls-tls")]
             InnerNetworkStream::RustlsTls(ref s) => s.get_ref().shutdown(how),
-            InnerNetworkStream::Mock(_) => Ok(()),
+            InnerNetworkStream::None => {
+                debug_assert!(false, "InnerNetworkStream::None must never be built");
+                Ok(())
+            }
         }
     }
 
@@ -116,8 +121,7 @@ impl NetworkStream {
             #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
             InnerNetworkStream::Tcp(_) => {
                 // get owned TcpStream
-                let tcp_stream =
-                    std::mem::replace(&mut self.inner, InnerNetworkStream::Mock(MockStream::new()));
+                let tcp_stream = mem::replace(&mut self.inner, InnerNetworkStream::None);
                 let tcp_stream = match tcp_stream {
                     InnerNetworkStream::Tcp(tcp_stream) => tcp_stream,
                     _ => unreachable!(),
@@ -149,10 +153,7 @@ impl NetworkStream {
 
                 let domain = DNSNameRef::try_from_ascii_str(tls_parameters.domain())
                     .map_err(error::connection)?;
-                let stream = StreamOwned::new(
-                    ClientSession::new(&Arc::new(connector.clone()), domain),
-                    tcp_stream,
-                );
+                let stream = StreamOwned::new(ClientSession::new(&connector, domain), tcp_stream);
 
                 InnerNetworkStream::RustlsTls(stream)
             }
@@ -161,11 +162,15 @@ impl NetworkStream {
 
     pub fn is_encrypted(&self) -> bool {
         match self.inner {
-            InnerNetworkStream::Tcp(_) | InnerNetworkStream::Mock(_) => false,
+            InnerNetworkStream::Tcp(_) => false,
             #[cfg(feature = "native-tls")]
             InnerNetworkStream::NativeTls(_) => true,
             #[cfg(feature = "rustls-tls")]
             InnerNetworkStream::RustlsTls(_) => true,
+            InnerNetworkStream::None => {
+                debug_assert!(false, "InnerNetworkStream::None must never be built");
+                false
+            }
         }
     }
 
@@ -180,7 +185,10 @@ impl NetworkStream {
             InnerNetworkStream::RustlsTls(ref mut stream) => {
                 stream.get_ref().set_read_timeout(duration)
             }
-            InnerNetworkStream::Mock(_) => Ok(()),
+            InnerNetworkStream::None => {
+                debug_assert!(false, "InnerNetworkStream::None must never be built");
+                Ok(())
+            }
         }
     }
 
@@ -198,7 +206,10 @@ impl NetworkStream {
                 stream.get_ref().set_write_timeout(duration)
             }
 
-            InnerNetworkStream::Mock(_) => Ok(()),
+            InnerNetworkStream::None => {
+                debug_assert!(false, "InnerNetworkStream::None must never be built");
+                Ok(())
+            }
         }
     }
 }
@@ -211,7 +222,10 @@ impl Read for NetworkStream {
             InnerNetworkStream::NativeTls(ref mut s) => s.read(buf),
             #[cfg(feature = "rustls-tls")]
             InnerNetworkStream::RustlsTls(ref mut s) => s.read(buf),
-            InnerNetworkStream::Mock(ref mut s) => s.read(buf),
+            InnerNetworkStream::None => {
+                debug_assert!(false, "InnerNetworkStream::None must never be built");
+                Ok(0)
+            }
         }
     }
 }
@@ -224,7 +238,10 @@ impl Write for NetworkStream {
             InnerNetworkStream::NativeTls(ref mut s) => s.write(buf),
             #[cfg(feature = "rustls-tls")]
             InnerNetworkStream::RustlsTls(ref mut s) => s.write(buf),
-            InnerNetworkStream::Mock(ref mut s) => s.write(buf),
+            InnerNetworkStream::None => {
+                debug_assert!(false, "InnerNetworkStream::None must never be built");
+                Ok(0)
+            }
         }
     }
 
@@ -235,7 +252,10 @@ impl Write for NetworkStream {
             InnerNetworkStream::NativeTls(ref mut s) => s.flush(),
             #[cfg(feature = "rustls-tls")]
             InnerNetworkStream::RustlsTls(ref mut s) => s.flush(),
-            InnerNetworkStream::Mock(ref mut s) => s.flush(),
+            InnerNetworkStream::None => {
+                debug_assert!(false, "InnerNetworkStream::None must never be built");
+                Ok(())
+            }
         }
     }
 }

src/transport/smtp/client/tls.rs

@@ -24,12 +24,15 @@ pub enum Tls {
     None,
     /// Start with insecure connection and use `STARTTLS` when available
     #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
     Opportunistic(TlsParameters),
     /// Start with insecure connection and require `STARTTLS`
     #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
     Required(TlsParameters),
     /// Use TLS wrapped connection
     #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
     Wrapper(TlsParameters),
 }
 
@@ -128,18 +131,12 @@ impl TlsParametersBuilder {
     /// depending on which one is available
     #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
     #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
-    // TODO: remove below line once native-tls is supported with async-std
-    #[allow(unreachable_code)]
     pub fn build(self) -> Result<TlsParameters, Error> {
-        // TODO: remove once native-tls is supported with async-std
-        #[cfg(all(feature = "rustls-tls", feature = "async-std1"))]
+        #[cfg(feature = "rustls-tls")]
         return self.build_rustls();
 
-        #[cfg(feature = "native-tls")]
+        #[cfg(not(feature = "rustls-tls"))]
         return self.build_native();
-
-        #[cfg(not(feature = "native-tls"))]
-        return self.build_rustls();
     }
 
     /// Creates a new `TlsParameters` using native-tls with the provided configuration
@@ -182,7 +179,7 @@ impl TlsParametersBuilder {
 
         tls.root_store.add_server_trust_anchors(&TLS_SERVER_ROOTS);
         Ok(TlsParameters {
-            connector: InnerTlsParameters::RustlsTls(tls),
+            connector: InnerTlsParameters::RustlsTls(Arc::new(tls)),
             domain: self.domain,
         })
     }
@@ -193,7 +190,7 @@ pub enum InnerTlsParameters {
     #[cfg(feature = "native-tls")]
     NativeTls(TlsConnector),
     #[cfg(feature = "rustls-tls")]
-    RustlsTls(ClientConfig),
+    RustlsTls(Arc<ClientConfig>),
 }
 
 impl TlsParameters {

src/transport/smtp/commands.rs

@@ -55,7 +55,7 @@ impl Display for Mail {
         write!(
             f,
             "MAIL FROM:<{}>",
-            self.sender.as_ref().map(|s| s.as_ref()).unwrap_or("")
+            self.sender.as_ref().map_or("", |s| s.as_ref())
         )?;
         for parameter in &self.parameters {
             write!(f, " {}", parameter)?;

src/transport/smtp/error.rs

@@ -76,8 +76,7 @@ impl Error {
     /// Returns the status code, if the error was generated from a response.
     pub fn status(&self) -> Option<Code> {
         match self.inner.kind {
-            Kind::Transient(code) => Some(code),
-            Kind::Permanent(code) => Some(code),
+            Kind::Transient(code) | Kind::Permanent(code) => Some(code),
             _ => None,
         }
     }

src/transport/smtp/mod.rs

@@ -116,7 +116,7 @@
 //! # }
 //! ```
 
-#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
+#[cfg(any(feature = "tokio1", feature = "async-std1"))]
 pub use self::async_transport::{AsyncSmtpTransport, AsyncSmtpTransportBuilder};
 #[cfg(feature = "r2d2")]
 pub use self::pool::PoolConfig;
@@ -137,7 +137,7 @@ use crate::transport::smtp::{
 use client::Tls;
 use std::time::Duration;
 
-#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
+#[cfg(any(feature = "tokio1", feature = "async-std1"))]
 mod async_transport;
 pub mod authentication;
 pub mod client;

src/transport/smtp/response.rs

@@ -122,7 +122,7 @@ impl Code {
     }
 
     /// Tells if the response is positive
-    pub fn is_positive(&self) -> bool {
+    pub fn is_positive(self) -> bool {
         matches!(
             self.severity,
             Severity::PositiveCompletion | Severity::PositiveIntermediate

src/transport/smtp/transport.rs

@@ -48,6 +48,7 @@ impl SmtpTransport {
     /// Creates an encrypted transport over submissions port, using the provided domain
     /// to validate TLS certificates.
     #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
     pub fn relay(relay: &str) -> Result<SmtpTransportBuilder, Error> {
         let tls_parameters = TlsParameters::new(relay.into())?;
 
@@ -68,6 +69,7 @@ impl SmtpTransport {
     /// An error is returned if the connection can't be upgraded. No credentials
     /// or emails will be sent to the server, protecting from downgrade attacks.
     #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
     pub fn starttls_relay(relay: &str) -> Result<SmtpTransportBuilder, Error> {
         let tls_parameters = TlsParameters::new(relay.into())?;
 
@@ -152,6 +154,7 @@ impl SmtpTransportBuilder {
 
     /// Set the TLS settings to use
     #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
     pub fn tls(mut self, tls: Tls) -> Self {
         self.info.tls = tls;
         self

src/transport/stub/mod.rs

@@ -28,10 +28,10 @@
 //! # }
 //! ```
 
-#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
+#[cfg(any(feature = "tokio1", feature = "async-std1"))]
 use crate::AsyncTransport;
 use crate::{address::Envelope, Transport};
-#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
+#[cfg(any(feature = "tokio1", feature = "async-std1"))]
 use async_trait::async_trait;
 use std::{error::Error as StdError, fmt};
 
@@ -80,7 +80,7 @@ impl Transport for StubTransport {
     }
 }
 
-#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
+#[cfg(any(feature = "tokio1", feature = "async-std1"))]
 #[async_trait]
 impl AsyncTransport for StubTransport {
     type Ok = ();

testdata/email_with_png.eml

@@ -1,13 +1,14 @@
-Date: Tue, 15 Nov 1994 08:12:31 GMT
+Date: Tue, 15 Nov 1994 08:12:31 -0000
 From: NoBody <nobody@domain.tld>
 Reply-To: Yuin <yuin@domain.tld>
 To: Hei <hei@domain.tld>
 Subject: Happy new year
 MIME-Version: 1.0
-Content-Type: multipart/related; boundary="0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1"
+Content-Type: multipart/related; 
+ boundary="GUEEoEeTXtLcK2sMhmH1RfC1co13g4rtnRUFjQFA"
 
 --0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1
-Content-Type: text/html; charset=utf8
+Content-Type: text/html; charset=utf-8
 Content-Transfer-Encoding: 7bit
 
 <p><b>Hello</b>, <i>world</i>! <img src=cid:123></p>

tests/transport_file.rs

@@ -1,6 +1,15 @@
+#[cfg(all(feature = "file-transport", feature = "builder"))]
+fn default_date() -> std::time::SystemTime {
+    use std::time::{Duration, SystemTime};
+
+    // Tue, 15 Nov 1994 08:12:31 GMT
+    SystemTime::UNIX_EPOCH + Duration::from_secs(784887151)
+}
+
 #[cfg(test)]
 #[cfg(all(feature = "file-transport", feature = "builder"))]
 mod sync {
+    use crate::default_date;
     use lettre::{FileTransport, Message, Transport};
     use std::{
         env::temp_dir,
@@ -15,7 +24,7 @@ mod sync {
             .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
             .to("Hei <hei@domain.tld>".parse().unwrap())
             .subject("Happy new year")
-            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
+            .date(default_date())
             .body(String::from("Be happy!"))
             .unwrap();
 
@@ -32,7 +41,7 @@ mod sync {
                 "Reply-To: Yuin <yuin@domain.tld>\r\n",
                 "To: Hei <hei@domain.tld>\r\n",
                 "Subject: Happy new year\r\n",
-                "Date: Tue, 15 Nov 1994 08:12:31 GMT\r\n",
+                "Date: Tue, 15 Nov 1994 08:12:31 -0000\r\n",
                 "Content-Transfer-Encoding: 7bit\r\n",
                 "\r\n",
                 "Be happy!"
@@ -50,7 +59,7 @@ mod sync {
             .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
             .to("Hei <hei@domain.tld>".parse().unwrap())
             .subject("Happy new year")
-            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
+            .date(default_date())
             .body(String::from("Be happy!"))
             .unwrap();
 
@@ -70,7 +79,7 @@ mod sync {
                 "Reply-To: Yuin <yuin@domain.tld>\r\n",
                 "To: Hei <hei@domain.tld>\r\n",
                 "Subject: Happy new year\r\n",
-                "Date: Tue, 15 Nov 1994 08:12:31 GMT\r\n",
+                "Date: Tue, 15 Nov 1994 08:12:31 -0000\r\n",
                 "Content-Transfer-Encoding: 7bit\r\n",
                 "\r\n",
                 "Be happy!"
@@ -92,55 +101,10 @@ mod sync {
     }
 }
 
-#[cfg(test)]
-#[cfg(all(feature = "file-transport", feature = "builder", feature = "tokio02"))]
-mod tokio_02 {
-    use lettre::{AsyncFileTransport, AsyncTransport, Message, Tokio02Executor};
-    use std::{
-        env::temp_dir,
-        fs::{read_to_string, remove_file},
-    };
-
-    use tokio02_crate as tokio;
-
-    #[tokio::test]
-    async fn file_transport_tokio02() {
-        let sender = AsyncFileTransport::<Tokio02Executor>::new(temp_dir());
-        let email = Message::builder()
-            .from("NoBody <nobody@domain.tld>".parse().unwrap())
-            .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-            .to("Hei <hei@domain.tld>".parse().unwrap())
-            .subject("Happy new year")
-            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
-            .body(String::from("Be happy!"))
-            .unwrap();
-
-        let result = sender.send(email).await;
-        let id = result.unwrap();
-
-        let eml_file = temp_dir().join(format!("{}.eml", id));
-        let eml = read_to_string(&eml_file).unwrap();
-
-        assert_eq!(
-            eml,
-            concat!(
-                "From: NoBody <nobody@domain.tld>\r\n",
-                "Reply-To: Yuin <yuin@domain.tld>\r\n",
-                "To: Hei <hei@domain.tld>\r\n",
-                "Subject: Happy new year\r\n",
-                "Date: Tue, 15 Nov 1994 08:12:31 GMT\r\n",
-                "Content-Transfer-Encoding: 7bit\r\n",
-                "\r\n",
-                "Be happy!"
-            )
-        );
-        remove_file(eml_file).unwrap();
-    }
-}
-
 #[cfg(test)]
 #[cfg(all(feature = "file-transport", feature = "builder", feature = "tokio1"))]
 mod tokio_1 {
+    use crate::default_date;
     use lettre::{AsyncFileTransport, AsyncTransport, Message, Tokio1Executor};
     use std::{
         env::temp_dir,
@@ -149,7 +113,6 @@ mod tokio_1 {
 
     use tokio1_crate as tokio;
 
-    #[cfg(feature = "tokio02")]
     #[tokio::test]
     async fn file_transport_tokio1() {
         let sender = AsyncFileTransport::<Tokio1Executor>::new(temp_dir());
@@ -158,7 +121,7 @@ mod tokio_1 {
             .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
             .to("Hei <hei@domain.tld>".parse().unwrap())
             .subject("Happy new year")
-            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
+            .date(default_date())
             .body(String::from("Be happy!"))
             .unwrap();
 
@@ -175,7 +138,7 @@ mod tokio_1 {
                 "Reply-To: Yuin <yuin@domain.tld>\r\n",
                 "To: Hei <hei@domain.tld>\r\n",
                 "Subject: Happy new year\r\n",
-                "Date: Tue, 15 Nov 1994 08:12:31 GMT\r\n",
+                "Date: Tue, 15 Nov 1994 08:12:31 -0000\r\n",
                 "Content-Transfer-Encoding: 7bit\r\n",
                 "\r\n",
                 "Be happy!"
@@ -192,6 +155,7 @@ mod tokio_1 {
     feature = "async-std1"
 ))]
 mod asyncstd_1 {
+    use crate::default_date;
     use lettre::{AsyncFileTransport, AsyncStd1Executor, AsyncTransport, Message};
     use std::{
         env::temp_dir,
@@ -206,7 +170,7 @@ mod asyncstd_1 {
             .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
             .to("Hei <hei@domain.tld>".parse().unwrap())
             .subject("Happy new year")
-            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
+            .date(default_date())
             .body(String::from("Be happy!"))
             .unwrap();
 
@@ -223,7 +187,7 @@ mod asyncstd_1 {
                 "Reply-To: Yuin <yuin@domain.tld>\r\n",
                 "To: Hei <hei@domain.tld>\r\n",
                 "Subject: Happy new year\r\n",
-                "Date: Tue, 15 Nov 1994 08:12:31 GMT\r\n",
+                "Date: Tue, 15 Nov 1994 08:12:31 -0000\r\n",
                 "Content-Transfer-Encoding: 7bit\r\n",
                 "\r\n",
                 "Be happy!"

tests/transport_sendmail.rs

@@ -20,34 +20,6 @@ mod sync {
     }
 }
 
-#[cfg(test)]
-#[cfg(all(
-    feature = "sendmail-transport",
-    feature = "builder",
-    feature = "tokio02"
-))]
-mod tokio_02 {
-    use lettre::{AsyncSendmailTransport, AsyncTransport, Message, Tokio02Executor};
-    use tokio02_crate as tokio;
-
-    #[tokio::test]
-    async fn sendmail_transport_tokio02() {
-        let sender = AsyncSendmailTransport::<Tokio02Executor>::new();
-        let email = Message::builder()
-            .from("NoBody <nobody@domain.tld>".parse().unwrap())
-            .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-            .to("Hei <hei@domain.tld>".parse().unwrap())
-            .subject("Happy new year")
-            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
-            .body(String::from("Be happy!"))
-            .unwrap();
-
-        let result = sender.send(email).await;
-        println!("{:?}", result);
-        assert!(result.is_ok());
-    }
-}
-
 #[cfg(test)]
 #[cfg(all(
     feature = "sendmail-transport",
@@ -66,7 +38,6 @@ mod tokio_1 {
             .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
             .to("Hei <hei@domain.tld>".parse().unwrap())
             .subject("Happy new year")
-            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
             .body(String::from("Be happy!"))
             .unwrap();
 
@@ -93,7 +64,6 @@ mod asyncstd_1 {
             .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
             .to("Hei <hei@domain.tld>".parse().unwrap())
             .subject("Happy new year")
-            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
             .body(String::from("Be happy!"))
             .unwrap();
 

tests/transport_smtp.rs

@@ -20,31 +20,6 @@ mod sync {
     }
 }
 
-#[cfg(test)]
-#[cfg(all(feature = "smtp-transport", feature = "builder", feature = "tokio02"))]
-mod tokio_02 {
-    use lettre::{AsyncSmtpTransport, AsyncTransport, Message, Tokio02Executor};
-
-    use tokio02_crate as tokio;
-
-    #[tokio::test]
-    async fn smtp_transport_simple_tokio02() {
-        let email = Message::builder()
-            .from("NoBody <nobody@domain.tld>".parse().unwrap())
-            .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-            .to("Hei <hei@domain.tld>".parse().unwrap())
-            .subject("Happy new year")
-            .body(String::from("Be happy!"))
-            .unwrap();
-
-        let sender: AsyncSmtpTransport<Tokio02Executor> =
-            AsyncSmtpTransport::<Tokio02Executor>::builder_dangerous("127.0.0.1")
-                .port(2525)
-                .build();
-        sender.send(email).await.unwrap();
-    }
-}
-
 #[cfg(test)]
 #[cfg(all(feature = "smtp-transport", feature = "builder", feature = "tokio1"))]
 mod tokio_1 {

tests/transport_stub.rs

@@ -20,31 +20,6 @@ mod sync {
     }
 }
 
-#[cfg(test)]
-#[cfg(all(feature = "builder", feature = "tokio02"))]
-mod tokio_02 {
-    use lettre::{transport::stub::StubTransport, AsyncTransport, Message};
-
-    use tokio02_crate as tokio;
-
-    #[tokio::test]
-    async fn stub_transport_tokio02() {
-        let sender_ok = StubTransport::new_ok();
-        let sender_ko = StubTransport::new_error();
-        let email = Message::builder()
-            .from("NoBody <nobody@domain.tld>".parse().unwrap())
-            .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-            .to("Hei <hei@domain.tld>".parse().unwrap())
-            .subject("Happy new year")
-            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
-            .body(String::from("Be happy!"))
-            .unwrap();
-
-        sender_ok.send(email.clone()).await.unwrap();
-        sender_ko.send(email).await.unwrap_err();
-    }
-}
-
 #[cfg(test)]
 #[cfg(all(feature = "builder", feature = "tokio1"))]
 mod tokio_1 {
@@ -61,7 +36,6 @@ mod tokio_1 {
             .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
             .to("Hei <hei@domain.tld>".parse().unwrap())
             .subject("Happy new year")
-            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
             .body(String::from("Be happy!"))
             .unwrap();
 
@@ -84,7 +58,6 @@ mod asyncstd_1 {
             .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
             .to("Hei <hei@domain.tld>".parse().unwrap())
             .subject("Happy new year")
-            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
             .body(String::from("Be happy!"))
             .unwrap();