Prepare 0.10.0-beta.1 (#555)

* Executor
* Move transports inside the transport module
* AsyncTransport refactor
* Update examples
* Update docs
* impl Default for AsyncSendmailTransport
* Implement AsyncFileTransport::read
* Generalize AsyncFileTransport AsyncTransport implementation
* Remove remaining uses of AsyncSmtpConnector

.github/workflows/audit.yml

@@ -6,7 +6,7 @@ jobs:
   audit:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v1
+      - uses: actions/checkout@v2
       - uses: actions-rs/audit-check@v1
         with:
           token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/test.yml

@@ -1,104 +1,127 @@
-name: Continuous integration
+name: CI
 
-on: [push, pull_request]
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+
+env:
+  RUST_BACKTRACE: full
 
 jobs:
-  test:
-    name: Test
+  rustfmt:
+    name: rustfmt / stable
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        rust:
-          - stable
-          - beta
-          - 1.40.0
-    steps:
-      - uses: actions/checkout@v1
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: ${{ matrix.rust }}
-          override: true
-      - run: sudo DEBIAN_FRONTEND=noninteractive apt-get update
-      - run: sudo DEBIAN_FRONTEND=noninteractive apt-get -y install postfix
-      - run: smtp-sink 2525 1000&
-      - uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --no-default-features --features=native-tls,builder,r2d2,smtp-transport,file-transport,sendmail-transport
-      - run: rm target/debug/deps/liblettre-*
-      - uses: actions-rs/cargo@v1
-        with:
-          command: test
-      - run: rm target/debug/deps/liblettre-*
-      - uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --no-default-features --features=builder,smtp-transport,file-transport,sendmail-transport
-      - run: rm target/debug/deps/liblettre-*
-      - uses: actions-rs/cargo@v1
-        if: matrix.rust != '1.40.0'
-        with:
-          command: test
-          args: --features=async-std1
-      - uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --features=tokio02
 
-  check:
-    name: Check
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        rust:
-          - stable
-          - beta
-          - 1.40.0
     steps:
-      - uses: actions/checkout@v1
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: ${{ matrix.rust }}
-          override: true
-      - uses: actions-rs/cargo@v1
-        with:
-          command: check
+      - name: Checkout
+        uses: actions/checkout@v2
 
-  fmt:
-    name: Rustfmt
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v1
-      - uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
+      - name: Install rust
+        run: |
+          rustup update --no-self-update stable
+          rustup component add rustfmt
+
+      - name: cargo fmt
+        run: cargo fmt --all -- --check
 
   clippy:
-    name: Clippy
+    name: clippy / stable
     runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Install rust
+        run: |
+          rustup update --no-self-update stable
+          rustup component add clippy
+
+      - name: Run clippy
+        run: cargo clippy --all-features --all-targets -- -D warnings
+
+  check:
+    name: check / stable
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Setup cache
+        uses: actions/cache@v2
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-check
+
+      - name: Install rust
+        run: rustup update --no-self-update stable
+      
+      - name: Install cargo hack
+        run: cargo install cargo-hack --debug
+
+      - name: Check with cargo hack
+        run: cargo hack check --feature-powerset --depth 3
+
+  test:
+    name: test / ${{ matrix.name }}
+    runs-on: ubuntu-latest
+
     strategy:
       matrix:
-        rust:
-          - stable
-    steps:
-      - uses: actions/checkout@v1
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ matrix.rust }}
-          override: true
-      - uses: actions-rs/cargo@v1
-        with:
-          command: clippy
-          args: -- -D warnings
+        include:
+          - name: stable
+            rust: stable
+          - name: beta
+            rust: beta
+          - name: 1.45.2
+            rust: 1.45.2
 
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Setup cache
+        uses: actions/cache@v2
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-test-${{ matrix.rust }}
+
+      - name: Install rust
+        run: |
+          rustup default ${{ matrix.rust }}
+          rustup update --no-self-update ${{ matrix.rust }}
+
+      - name: Install postfix  
+        run: |
+          DEBIAN_FRONTEND=noninteractive sudo apt-get update
+          DEBIAN_FRONTEND=noninteractive sudo apt-get -y install postfix
+
+      - name: Run SMTP server
+        run: smtp-sink 2525 1000&
+
+      - name: Test with no default features
+        run: cargo test --no-default-features
+
+      - name: Test with default features
+        run: cargo test
+
+      - name: Test with all features
+        run: cargo test --all-features
+  
 #  coverage:
 #    name: Coverage
 #    runs-on: ubuntu-latest
 #    steps:
-#      - uses: actions/checkout@v1
+#      - uses: actions/checkout@v2
 #      - uses: actions-rs/toolchain@v1
 #        with:
 #          toolchain: nightly

CHANGELOG.md

@@ -5,7 +5,8 @@
 
 Several breaking changes were made between 0.9 and 0.10, but changes should be straightforward:
 
-* The `lettre_email` crate has been merged into `lettre`. To migrate, replace `lettre_email` with `lettre::builder`
+* MSRV is now 1.45.2
+* 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,
   rename `SendableEmail` to `Email`.
@@ -13,33 +14,46 @@ Several breaking changes were made between 0.9 and 0.10, but changes should be s
 
 #### Features
 
-* Add `rustls` support ([29e4829](https://github.com/lettre/lettre/commit/29e4829), [39a0686](https://github.com/lettre/lettre/commit/39a0686))
-* Allow providing a custom message id ([50d96ad](https://github.com/lettre/lettre/commit/50d96ad))
-* Add `EmailAddress::is_valid` and `into_inner` ([e5a1248](https://github.com/lettre/lettre/commit/e5a1248))
-* Accept `Into<SendableEmail>` ([86e5181](https://github.com/lettre/lettre/commit/86e5181))
-* Allow forcing of a specific auth ([bf2adca](https://github.com/lettre/lettre/commit/bf2adca))
-* Add `build_body` ([e927d0b](https://github.com/lettre/lettre/commit/e927d0b))
+* Add `tokio` 0.2 and 1.0 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
+* Allow providing a custom message id
+* Allow sending raw emails
 
-#### Changes
+#### Breaking Changes
 
-* Move CI to Github Actions ([3eef024](https://github.com/lettre/lettre/commit/3eef024))
-* MSRV is now 1.36 ([d227cd4](https://github.com/lettre/lettre/commit/d227cd4))
-* Merged `lettre_email` into `lettre` ([0f3f27f](https://github.com/lettre/lettre/commit/0f3f27f))
-* Rename `serde-impls` feature to `serde` ([aac3e00](https://github.com/lettre/lettre/commit/aac3e00))
-* Use criterion for benchmarks ([eda7fc1](https://github.com/lettre/lettre/commit/eda7fc1))
-* Update to nom 5 ([5bc1cba](https://github.com/lettre/lettre/commit/5bc1cba))
-* Change website url schemes to https ([6014f5c](https://github.com/lettre/lettre/commit/6014f5c))
-* Use serde's `derive` feature instead of the `serde_derive` crate ([4fbe700](https://github.com/lettre/lettre/commit/4fbe700))
-* Merge `Email` and `SendableEmail` into `lettre::Email` ([ce37464](https://github.com/lettre/lettre/commit/ce37464))
-* When the hostname feature is disabled or hostname cannot be fetched, `127.0.0.1` is used instead of `localhost` as
-  EHLO parameter (for better RFC compliance and mail server compatibility)
+* Merge `lettre_email` into `lettre`
+* Merge `Email` and `SendableEmail` into `lettre::message::Email`
+* SmtpTransport is now an high level SMTP client. It provides connection pooling and shortcuts for building clients using commonly desired values
+* Refactor `TlsParameters` implementation to not expose the internal TLS library
+* `FileTransport` writes emails into `.eml` instead of `.json`
+* When the hostname feature is disabled or hostname cannot be fetched, `127.0.0.1` is used instead of `localhost` as EHLO parameter (for better RFC compliance and mail server compatibility)
 * The `new` method of `ClientId` is deprecated
+* Rename `serde-impls` feature to `serde`
+
 
 #### Bug Fixes
 
-* Timeout bug causing infinite hang ([6eff9d3](https://github.com/lettre/lettre/commit/6eff9d3))
-* Fix doc tests in website ([947af0a](https://github.com/lettre/lettre/commit/947af0a))
-* Fix docs for `domain` field ([0e05e0e](https://github.com/lettre/lettre/commit/0e05e0e))
+* Fix argument injection in `SendmailTransport` (see [RUSTSEC-2020-0069](https://github.com/RustSec/advisory-db/blob/master/crates/lettre/RUSTSEC-2020-0069.md))
+* Correctly encode header values containing non-ASCII characters
+* Timeout bug causing infinite hang
+* Fix doc tests in website
+* Fix docs for `domain` field
+
+#### Misc
+
+* Improve documentation, examples and tests
+* Replace `line-wrap`, `email`, `bufstream` with our own implementations
+* Remove `bytes`
+* Remove `time`
+* Remove `fast_chemail`
+* Update `base64` to 0.13
+* Update `hostname` to 0.3
+* Update to `nom` 6
+* Replace `log` with `tracing`
+* Move CI to Github Actions
+* Use criterion for benchmarks
 
 <a name="v0.9.2"></a>
 ### v0.9.2 (2019-06-11)

CODE_OF_CONDUCT.md

@@ -34,7 +34,7 @@ This Code of Conduct applies both within project spaces and in public spaces whe
 
 ## Enforcement
 
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at contact@lettre.at. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at contact@lettre.rs. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
 
 Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
 

Cargo.toml

@@ -1,9 +1,10 @@
 [package]
 name = "lettre"
-version = "0.10.0-alpha.0" # remember to update html_root_url and README.md
+# remember to update html_root_url and README.md (Cargo.toml example and deps.rs badge)
+version = "0.10.0-beta.1"
 description = "Email client"
 readme = "README.md"
-homepage = "https://lettre.at"
+homepage = "https://lettre.rs"
 repository = "https://github.com/lettre/lettre"
 license = "MIT"
 authors = ["Alexis Mousset <contact@amousset.me>", "Paolo Barbolini <paolo@paolo565.org>"]
@@ -17,33 +18,51 @@ is-it-maintained-open-issues = { repository = "lettre/lettre" }
 maintenance = { status = "actively-developed" }
 
 [dependencies]
-async-attributes = { version = "1.1", optional = true }
-async-std = { version = "1.5", optional = true, features = ["unstable"] }
-async-trait = { version = "0.1", optional = true }
-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.14", optional = true }
-futures-io = { version = "0.3", optional = true }
-futures-util = { version = "0.3", features = ["io"], optional = true }
-base64 = { version = "0.12", optional = true }
-hostname = { version = "0.3", optional = true }
-hyperx = { version = "1", optional = true, features = ["headers"] }
 idna = "0.2"
-tracing = { version = "0.1.16", default-features = false, features = ["std"], optional = true }
-mime = { version = "0.3", optional = true }
-native-tls = { version = "0.2", optional = true }
-nom = { version = "5", optional = true }
-once_cell = "1"
+tracing = { version = "0.1.16", default-features = false, features = ["std"], optional = true } # feature
+
+# builder
+hyperx = { version = "1", optional = true, features = ["headers"] }
+mime = { version = "0.3.4", optional = true }
+uuid = { version = "0.8", features = ["v4"] }
+rand = { version = "0.8", optional = true }
 quoted_printable = { version = "0.4", optional = true }
-r2d2 = { version = "0.8", optional = true }
-rand = { version = "0.7", optional = true }
-regex = "1"
-rustls = { version = "0.18", optional = true }
+base64 = { version = "0.13", optional = true }
+once_cell = "1"
+regex = { version = "1", default-features = false, features = ["std", "unicode-case"] }
+
+# file transport
 serde = { version = "1", optional = true, features = ["derive"] }
 serde_json = { version = "1", optional = true }
-uuid = { version = "0.8", features = ["v4"] }
+
+# smtp
+nom = { version = "6", default-features = false, features = ["alloc"], optional = true }
+r2d2 = { version = "0.8", optional = true } # feature
+hostname = { version = "0.3", optional = true } # feature
+
+## tls
+native-tls = { version = "0.2", optional = true } # feature
+rustls = { version = "0.19", features = ["dangerous_configuration"], optional = true }
 webpki = { version = "0.21", optional = true }
-webpki-roots = { version = "0.20", optional = true }
+webpki-roots = { version = "0.21", optional = true }
+
+# async
+futures-io = { version = "0.3.7", optional = true }
+futures-util = { version = "0.3.7", default-features = false, features = ["io"], optional = true }
+async-trait = { version = "0.1", optional = true }
+
+## async-std
+async-std = { version = "1.8", optional = true, features = ["unstable"] }
+#async-native-tls = { version = "0.3.3", optional = true }
+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 }
 
 [dev-dependencies]
 criterion = "0.3"
@@ -51,43 +70,86 @@ 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"
+maud = "0.22.1"
 
 [[bench]]
 harness = false
 name = "transport_smtp"
 
 [features]
-async-std1 = ["async-std", "async-trait", "async-attributes"]
-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"]
+default = ["smtp-transport", "native-tls", "hostname", "r2d2", "builder"]
 builder = ["mime", "base64", "hyperx", "rand", "quoted_printable"]
-default = ["file-transport", "smtp-transport", "native-tls", "hostname", "r2d2", "sendmail-transport", "builder"]
-file-transport = ["serde", "serde_json"]
-# native-tls
-rustls-tls = ["webpki", "webpki-roots", "rustls"]
+
+# transports
+file-transport = []
+file-transport-envelope = ["serde", "serde_json", "file-transport"]
 sendmail-transport = []
 smtp-transport = ["base64", "nom"]
 
+rustls-tls = ["webpki", "webpki-roots", "rustls"]
+
+# async
+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"]
+
 [package.metadata.docs.rs]
 all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
+
+[[example]]
+name = "basic_html"
+required-features = ["file-transport", "builder"]
+
+[[example]]
+name = "maud_html"
+required-features = ["file-transport", "builder"]
 
 [[example]]
 name = "smtp"
-required-features = ["smtp-transport"]
+required-features = ["smtp-transport", "builder"]
 
 [[example]]
 name = "smtp_tls"
-required-features = ["smtp-transport", "native-tls"]
+required-features = ["smtp-transport", "native-tls", "builder"]
 
 [[example]]
 name = "smtp_starttls"
-required-features = ["smtp-transport", "native-tls"]
+required-features = ["smtp-transport", "native-tls", "builder"]
+
+[[example]]
+name = "smtp_selfsigned"
+required-features = ["smtp-transport", "native-tls", "builder"]
 
 [[example]]
 name = "tokio02_smtp_tls"
-required-features = ["smtp-transport", "tokio02", "tokio02-native-tls"]
+required-features = ["smtp-transport", "tokio02", "tokio02-native-tls", "builder"]
 
 [[example]]
 name = "tokio02_smtp_starttls"
-required-features = ["smtp-transport", "tokio02", "tokio02-native-tls"]
+required-features = ["smtp-transport", "tokio02", "tokio02-native-tls", "builder"]
+
+[[example]]
+name = "tokio1_smtp_tls"
+required-features = ["smtp-transport", "tokio1", "tokio1-native-tls", "builder"]
+
+[[example]]
+name = "tokio1_smtp_starttls"
+required-features = ["smtp-transport", "tokio1", "tokio1-native-tls", "builder"]
+
+[[example]]
+name = "asyncstd1_smtp_tls"
+required-features = ["smtp-transport", "async-std1", "async-std1-rustls-tls", "builder"]
+
+[[example]]
+name = "asyncstd1_smtp_starttls"
+required-features = ["smtp-transport", "async-std1", "async-std1-rustls-tls", "builder"]

README.md

@@ -21,12 +21,19 @@
     <img src="https://badges.gitter.im/lettre/lettre.svg"
       alt="chat on gitter" />
   </a>
-  <a href="https://lettre.at">
+  <a href="https://lettre.rs">
     <img src="https://img.shields.io/badge/visit-website-blueviolet"
       alt="website" />
   </a>
 </div>
 
+<div align="center">
+  <a href="https://deps.rs/crate/lettre/0.10.0-beta.1">
+    <img src="https://deps.rs/crate/lettre/0.10.0-beta.1/status.svg"
+      alt="dependency status" />
+  </a>
+</div>
+
 ---
 
 **NOTE**: this readme refers to the 0.10 version of lettre, which is
@@ -45,7 +52,7 @@ Lettre provides the following features:
 * Unicode support (for email content and addresses)
 * Secure delivery with SMTP using encryption and authentication
 * Easy email builders
-* Async support (incomplete)
+* Async support
 
 Lettre does not provide (for now):
 
@@ -53,13 +60,13 @@ Lettre does not provide (for now):
 
 ## Example
 
-This library requires Rust 1.40 or newer.
+This library requires Rust 1.45 or newer.
 To use this library, add the following to your `Cargo.toml`:
 
 
 ```toml
 [dependencies]
-lettre = "0.10.0-alpha.1"
+lettre = "0.10.0-beta.1"
 ```
 
 ```rust,no_run

SECURITY.md

@@ -1,7 +1,7 @@
 ## Report a security issue
 
 The lettre project team welcomes security reports and is committed to providing prompt attention to security issues.
-Security issues should be reported privately via [security@lettre.at](mailto:security@lettre.at). Security issues
+Security issues should be reported privately via [security@lettre.rs](mailto:security@lettre.rs). Security issues
 should not be reported via the public Github Issue tracker.
 
 ## Security advisories

benches/transport_smtp.rs

@@ -2,7 +2,9 @@ use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use lettre::{Message, SmtpTransport, Transport};
 
 fn bench_simple_send(c: &mut Criterion) {
-    let sender = SmtpTransport::builder("127.0.0.1").port(2525).build();
+    let sender = SmtpTransport::builder_dangerous("127.0.0.1")
+        .port(2525)
+        .build();
 
     c.bench_function("send email", move |b| {
         b.iter(|| {
@@ -11,7 +13,7 @@ fn bench_simple_send(c: &mut Criterion) {
                 .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 result = black_box(sender.send(&email));
             assert!(result.is_ok());
@@ -20,7 +22,9 @@ fn bench_simple_send(c: &mut Criterion) {
 }
 
 fn bench_reuse_send(c: &mut Criterion) {
-    let sender = SmtpTransport::builder("127.0.0.1").port(2525).build();
+    let sender = SmtpTransport::builder_dangerous("127.0.0.1")
+        .port(2525)
+        .build();
     c.bench_function("send email with connection reuse", move |b| {
         b.iter(|| {
             let email = Message::builder()
@@ -28,7 +32,7 @@ fn bench_reuse_send(c: &mut Criterion) {
                 .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 result = black_box(sender.send(&email));
             assert!(result.is_ok());

examples/README.md

@@ -0,0 +1,24 @@
+# Lettre Examples
+
+This folder contains examples showing how to use lettre in your own projects.
+
+## Message builder examples
+
+- [basic_html.rs] - Create an HTML email.
+- [maud_html.rs] - Create an HTML email using a [maud](https://github.com/lambda-fairy/maud) template.
+
+## SMTP Examples
+
+- [smtp.rs] - Send an email using a local SMTP daemon on port 25 as a relay.
+- [smtp_tls.rs] - Send an email over SMTP encrypted with TLS and authenticating with username and password.
+- [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_`.
+
+[basic_html.rs]: ./basic_html.rs
+[maud_html.rs]: ./maud_html.rs
+[smtp.rs]: ./smtp.rs
+[smtp_tls.rs]: ./smtp_tls.rs
+[smtp_starttls.rs]: ./smtp_starttls.rs
+[smtp_selfsigned.rs]: ./smtp_selfsigned.rs

examples/asyncstd1_smtp_starttls.rs

@@ -0,0 +1,32 @@
+use lettre::{
+    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncStd1Executor,
+    AsyncStd1Transport, Message,
+};
+
+#[async_std::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<AsyncStd1Executor> =
+        AsyncSmtpTransport::<AsyncStd1Executor>::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/asyncstd1_smtp_tls.rs

@@ -0,0 +1,32 @@
+use lettre::{
+    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncStd1Executor,
+    AsyncStd1Transport, Message,
+};
+
+#[async_std::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<AsyncStd1Executor> =
+        AsyncSmtpTransport::<AsyncStd1Executor>::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/basic_html.rs

@@ -0,0 +1,53 @@
+use lettre::{
+    message::{header, MultiPart, SinglePart},
+    FileTransport, Message, Transport,
+};
+
+fn main() {
+    // The html we want to send.
+    let html = r#"<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Hello from Lettre!</title>
+</head>
+<body>
+    <div style="display: flex; flex-direction: column; align-items: center;">
+        <h2 style="font-family: Arial, Helvetica, sans-serif;">Hello from Lettre!</h2>
+        <h4 style="font-family: Arial, Helvetica, sans-serif;">A mailer library for Rust</h4>
+    </div>
+</body>
+</html>"#;
+
+    // Build the message.
+    let email = Message::builder()
+        .from("NoBody <nobody@domain.tld>".parse().unwrap())
+        .to("Hei <hei@domain.tld>".parse().unwrap())
+        .subject("Hello from Lettre!")
+        .multipart(
+            MultiPart::alternative() // This is composed of two parts.
+                .singlepart(
+                    SinglePart::builder()
+                        .header(header::ContentType(
+                            "text/plain; charset=utf8".parse().unwrap(),
+                        ))
+                        .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(),
+                        ))
+                        .body(String::from(html)),
+                ),
+        )
+        .expect("failed to build email");
+
+    // Create our mailer. Please see the other examples for creating SMTP mailers.
+    // The path given here must exist on the filesystem.
+    let mailer = FileTransport::new("./");
+
+    // Store the message when you're ready.
+    mailer.send(&email).expect("failed to deliver message");
+}

examples/maud_html.rs

@@ -0,0 +1,62 @@
+use lettre::{
+    message::{header, MultiPart, SinglePart},
+    FileTransport, Message, Transport,
+};
+use maud::html;
+
+fn main() {
+    // The recipient's name. We might obtain this from a form or their email address.
+    let recipient = "Hei";
+
+    // Create the html we want to send.
+    let html = html! {
+        head {
+            title { "Hello from Lettre!" }
+            style type="text/css" {
+                "h2, h4 { font-family: Arial, Helvetica, sans-serif; }"
+            }
+        }
+        div style="display: flex; flex-direction: column; align-items: center;" {
+            h2 { "Hello from Lettre!" }
+            // Substitute in the name of our recipient.
+            p { "Dear " (recipient) "," }
+            p { "This email was sent with Lettre, a mailer library for Rust!"}
+            p {
+                "This example uses "
+                a href="https://crates.io/crates/maud" { "maud" }
+                ". It is about 20% cooler than the basic HTML example."
+            }
+        }
+    };
+
+    // Build the message.
+    let email = Message::builder()
+        .from("NoBody <nobody@domain.tld>".parse().unwrap())
+        .to("Hei <hei@domain.tld>".parse().unwrap())
+        .subject("Hello from Lettre!")
+        .multipart(
+            MultiPart::alternative() // This is composed of two parts.
+                .singlepart(
+                    SinglePart::builder()
+                        .header(header::ContentType(
+                            "text/plain; charset=utf8".parse().unwrap(),
+                        ))
+                        .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(),
+                        ))
+                        .body(html.into_string()),
+                ),
+        )
+        .expect("failed to build email");
+
+    // Create our mailer. Please see the other examples for creating SMTP mailers.
+    // The path given here must exist on the filesystem.
+    let mailer = FileTransport::new("./");
+
+    // Store the message when you're ready.
+    mailer.send(&email).expect("failed to deliver message");
+}

examples/smtp.rs

@@ -8,7 +8,7 @@ fn main() {
         .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();
 
     // Open a local connection on port 25

examples/smtp_selfsigned.rs

@@ -0,0 +1,44 @@
+use std::fs;
+
+use lettre::{
+    transport::smtp::{
+        authentication::Credentials,
+        client::{Certificate, Tls, TlsParameters},
+    },
+    Message, SmtpTransport, Transport,
+};
+
+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 year")
+        .body(String::from("Be happy!"))
+        .unwrap();
+
+    // Use a custom certificate stored on disk to securely verify the server's certificate
+    let pem_cert = fs::read("certificate.pem").unwrap();
+    let cert = Certificate::from_pem(&pem_cert).unwrap();
+    let tls = TlsParameters::builder("smtp.server.com".to_string())
+        .add_root_certificate(cert)
+        .build()
+        .unwrap();
+
+    let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
+
+    // Open a remote connection to the smtp server
+    let mailer = SmtpTransport::builder_dangerous("smtp.server.com")
+        .port(465)
+        .tls(Tls::Wrapper(tls))
+        .credentials(creds)
+        .build();
+
+    // Send the email
+    match mailer.send(&email) {
+        Ok(_) => println!("Email sent successfully!"),
+        Err(e) => panic!("Could not send email: {:?}", e),
+    }
+}

examples/smtp_starttls.rs

@@ -8,7 +8,7 @@ fn main() {
         .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/smtp_tls.rs

@@ -8,7 +8,7 @@ fn main() {
         .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/tokio02_smtp_starttls.rs

@@ -4,7 +4,7 @@
 use tokio02_crate as tokio;
 
 use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, Message, Tokio02Connector,
+    transport::smtp::authentication::Credentials, AsyncSmtpTransport, Message, Tokio02Executor,
     Tokio02Transport,
 };
 
@@ -17,16 +17,17 @@ async fn main() {
         .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
         .to("Hei <hei@domain.tld>".parse().unwrap())
         .subject("Happy new async year")
-        .body("Be happy with async!")
+        .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::<Tokio02Connector>::starttls_relay("smtp.gmail.com")
-        .unwrap()
-        .credentials(creds)
-        .build();
+    let mailer: AsyncSmtpTransport<Tokio02Executor> =
+        AsyncSmtpTransport::<Tokio02Executor>::starttls_relay("smtp.gmail.com")
+            .unwrap()
+            .credentials(creds)
+            .build();
 
     // Send the email
     match mailer.send(email).await {

examples/tokio02_smtp_tls.rs

@@ -4,7 +4,7 @@
 use tokio02_crate as tokio;
 
 use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, Message, Tokio02Connector,
+    transport::smtp::authentication::Credentials, AsyncSmtpTransport, Message, Tokio02Executor,
     Tokio02Transport,
 };
 
@@ -17,16 +17,17 @@ async fn main() {
         .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
         .to("Hei <hei@domain.tld>".parse().unwrap())
         .subject("Happy new async year")
-        .body("Be happy with async!")
+        .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::<Tokio02Connector>::relay("smtp.gmail.com")
-        .unwrap()
-        .credentials(creds)
-        .build();
+    let mailer: AsyncSmtpTransport<Tokio02Executor> =
+        AsyncSmtpTransport::<Tokio02Executor>::relay("smtp.gmail.com")
+            .unwrap()
+            .credentials(creds)
+            .build();
 
     // Send the email
     match mailer.send(email).await {

examples/tokio1_smtp_starttls.rs

@@ -0,0 +1,37 @@
+// 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 tokio1_crate as tokio;
+
+use lettre::{
+    transport::smtp::authentication::Credentials, AsyncSmtpTransport, Message, Tokio1Executor,
+    Tokio1Transport,
+};
+
+#[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<Tokio1Executor> =
+        AsyncSmtpTransport::<Tokio1Executor>::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/tokio1_smtp_tls.rs

@@ -0,0 +1,37 @@
+// 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 tokio1_crate as tokio;
+
+use lettre::{
+    transport::smtp::authentication::Credentials, AsyncSmtpTransport, Message, Tokio1Executor,
+    Tokio1Transport,
+};
+
+#[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<Tokio1Executor> =
+        AsyncSmtpTransport::<Tokio1Executor>::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

@@ -0,0 +1,154 @@
+#[cfg(feature = "builder")]
+use std::convert::TryFrom;
+
+use super::Address;
+#[cfg(feature = "builder")]
+use crate::message::header::{self, Headers};
+#[cfg(feature = "builder")]
+use crate::message::{Mailbox, Mailboxes};
+use crate::Error;
+
+/// Simple email envelope representation
+///
+/// We only accept mailboxes, and do not support source routes (as per RFC).
+#[derive(PartialEq, Eq, Clone, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct Envelope {
+    /// The envelope recipient's addresses
+    ///
+    /// This can not be empty.
+    forward_path: Vec<Address>,
+    /// The envelope sender address
+    reverse_path: Option<Address>,
+}
+
+impl Envelope {
+    /// Creates a new envelope, which may fail if `to` is empty.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::str::FromStr;
+    /// # use lettre::Address;
+    /// # use lettre::address::Envelope;
+    ///
+    /// # use std::error::Error;
+    /// # fn main() -> Result<(), Box<dyn Error>> {
+    /// let sender = Address::from_str("from@email.com")?;
+    /// let recipients = vec![Address::from_str("to@email.com")?];
+    ///
+    /// let envelope = Envelope::new(Some(sender), recipients);
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// # Errors
+    ///
+    /// If `to` has no elements in it.
+    pub fn new(from: Option<Address>, to: Vec<Address>) -> Result<Envelope, Error> {
+        if to.is_empty() {
+            return Err(Error::MissingTo);
+        }
+        Ok(Envelope {
+            forward_path: to,
+            reverse_path: from,
+        })
+    }
+
+    /// Gets the destination addresses of the envelope.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::str::FromStr;
+    /// # use lettre::Address;
+    /// # use lettre::address::Envelope;
+    ///
+    /// # use std::error::Error;
+    /// # fn main() -> Result<(), Box<dyn Error>> {
+    /// let sender = Address::from_str("from@email.com")?;
+    /// let recipients = vec![Address::from_str("to@email.com")?];
+    ///
+    /// let envelope = Envelope::new(Some(sender), recipients.clone())?;
+    /// assert_eq!(envelope.to(), recipients.as_slice());
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn to(&self) -> &[Address] {
+        self.forward_path.as_slice()
+    }
+
+    /// Gets the sender of the envelope.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::str::FromStr;
+    /// # use lettre::Address;
+    /// # use lettre::address::Envelope;
+    ///
+    /// # use std::error::Error;
+    /// # fn main() -> Result<(), Box<dyn Error>> {
+    /// let sender = Address::from_str("from@email.com")?;
+    /// let recipients = vec![Address::from_str("to@email.com")?];
+    ///
+    /// let envelope = Envelope::new(Some(sender), recipients.clone())?;
+    /// assert!(envelope.from().is_some());
+    ///
+    /// let senderless = Envelope::new(None, recipients.clone())?;
+    /// assert!(senderless.from().is_none());
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn from(&self) -> Option<&Address> {
+        self.reverse_path.as_ref()
+    }
+
+    /// Check if any of the addresses in the envelope contains non-ascii chars
+    pub(crate) fn has_non_ascii_addresses(&self) -> bool {
+        self.reverse_path
+            .iter()
+            .chain(self.forward_path.iter())
+            .any(|a| !a.is_ascii())
+    }
+}
+
+#[cfg(feature = "builder")]
+impl TryFrom<&Headers> for Envelope {
+    type Error = Error;
+
+    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()),
+            // ... else try From
+            None => match headers.get::<header::From>() {
+                Some(header::From(a)) => {
+                    let from: Vec<Mailbox> = a.clone().into();
+                    if from.len() > 1 {
+                        return Err(Error::TooManyFrom);
+                    }
+                    Some(from[0].email.clone())
+                }
+                None => None,
+            },
+        };
+
+        fn add_addresses_from_mailboxes(
+            addresses: &mut Vec<Address>,
+            mailboxes: Option<&Mailboxes>,
+        ) {
+            if let Some(mailboxes) = mailboxes {
+                for mailbox in mailboxes.iter() {
+                    addresses.push(mailbox.email.clone());
+                }
+            }
+        }
+        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));
+
+        Self::new(from, to)
+    }
+}

src/address/mod.rs

@@ -0,0 +1,12 @@
+//! Email addresses
+
+#[cfg(feature = "serde")]
+mod serde;
+
+mod envelope;
+mod types;
+
+pub use self::{
+    envelope::Envelope,
+    types::{Address, AddressError},
+};

src/address/serde.rs

@@ -0,0 +1,112 @@
+use std::fmt::{Formatter, Result as FmtResult};
+
+use serde::{
+    de::{Deserializer, Error as DeError, MapAccess, Visitor},
+    ser::Serializer,
+    Deserialize, Serialize,
+};
+
+use super::Address;
+
+impl Serialize for Address {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(self.as_ref())
+    }
+}
+
+impl<'de> Deserialize<'de> for Address {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        enum Field {
+            User,
+            Domain,
+        }
+
+        const FIELDS: &[&str] = &["user", "domain"];
+
+        impl<'de> Deserialize<'de> for Field {
+            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                struct FieldVisitor;
+
+                impl<'de> Visitor<'de> for FieldVisitor {
+                    type Value = Field;
+
+                    fn expecting(&self, formatter: &mut Formatter<'_>) -> FmtResult {
+                        formatter.write_str("'user' or 'domain'")
+                    }
+
+                    fn visit_str<E>(self, value: &str) -> Result<Field, E>
+                    where
+                        E: DeError,
+                    {
+                        match value {
+                            "user" => Ok(Field::User),
+                            "domain" => Ok(Field::Domain),
+                            _ => Err(DeError::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+
+                deserializer.deserialize_identifier(FieldVisitor)
+            }
+        }
+
+        struct AddressVisitor;
+
+        impl<'de> Visitor<'de> for AddressVisitor {
+            type Value = Address;
+
+            fn expecting(&self, formatter: &mut Formatter<'_>) -> FmtResult {
+                formatter.write_str("email address string or object")
+            }
+
+            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
+            where
+                E: DeError,
+            {
+                s.parse().map_err(DeError::custom)
+            }
+
+            fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
+            where
+                V: MapAccess<'de>,
+            {
+                let mut user = None;
+                let mut domain = None;
+                while let Some(key) = map.next_key()? {
+                    match key {
+                        Field::User => {
+                            if user.is_some() {
+                                return Err(DeError::duplicate_field("user"));
+                            }
+                            let val = map.next_value()?;
+                            Address::check_user(val).map_err(DeError::custom)?;
+                            user = Some(val);
+                        }
+                        Field::Domain => {
+                            if domain.is_some() {
+                                return Err(DeError::duplicate_field("domain"));
+                            }
+                            let val = map.next_value()?;
+                            Address::check_domain(val).map_err(DeError::custom)?;
+                            domain = Some(val);
+                        }
+                    }
+                }
+                let user: &str = user.ok_or_else(|| DeError::missing_field("user"))?;
+                let domain: &str = domain.ok_or_else(|| DeError::missing_field("domain"))?;
+                Ok(Address::new(user, domain).unwrap())
+            }
+        }
+
+        deserializer.deserialize_any(AddressVisitor)
+    }
+}

src/address/types.rs

@@ -12,11 +12,36 @@ use std::{
     str::FromStr,
 };
 
-/// Email address
+/// Represents an email address with a user and a domain name.
 ///
 /// This type contains email in canonical form (_user@domain.tld_).
 ///
 /// **NOTE**: Enable feature "serde" to be able serialize/deserialize it using [serde](https://serde.rs/).
+///
+/// # Examples
+///
+/// You can create an `Address` from a user and a domain:
+///
+/// ```
+/// # use lettre::Address;
+/// # use std::error::Error;
+/// # fn main() -> Result<(), Box<dyn Error>> {
+/// let address = Address::new("example", "email.com")?;
+/// # Ok(())
+/// # }
+/// ```
+///
+/// You can also create an `Address` from a string literal by parsing it:
+///
+/// ```
+/// use std::str::FromStr;
+/// # use lettre::Address;
+/// # use std::error::Error;
+/// # fn main() -> Result<(), Box<dyn Error>> {
+/// let address = Address::from_str("example@email.com")?;
+/// # Ok(())
+/// # }
+/// ```
 #[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
 pub struct Address {
     /// Complete address
@@ -62,22 +87,62 @@ static DOMAIN_RE: Lazy<Regex> = Lazy::new(|| {
 static LITERAL_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"(?i)\[([A-f0-9:\.]+)\]\z").unwrap());
 
 impl Address {
-    /// Create email address from parts
+    /// Creates a new email address from a user and domain.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lettre::Address;
+    ///
+    /// # use std::error::Error;
+    /// # fn main() -> Result<(), Box<dyn Error>> {
+    /// let address = Address::new("example", "email.com")?;
+    /// let expected: Address = "example@email.com".parse()?;
+    /// assert_eq!(expected, address);
+    /// # Ok(())
+    /// # }
+    /// ```
     pub fn new<U: AsRef<str>, D: AsRef<str>>(user: U, domain: D) -> Result<Self, AddressError> {
         (user, domain).try_into()
     }
 
-    /// Get the user part of this `Address`
+    /// Gets the user portion of the `Address`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lettre::Address;
+    ///
+    /// # use std::error::Error;
+    /// # fn main() -> Result<(), Box<dyn Error>> {
+    /// let address = Address::new("example", "email.com")?;
+    /// assert_eq!("example", address.user());
+    /// # Ok(())
+    /// # }
+    /// ```
     pub fn user(&self) -> &str {
         &self.serialized[..self.at_start]
     }
 
-    /// Get the domain part of this `Address`
+    /// Gets the domain portion of the `Address`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lettre::Address;
+    ///
+    /// # use std::error::Error;
+    /// # fn main() -> Result<(), Box<dyn Error>> {
+    /// let address = Address::new("example", "email.com")?;
+    /// assert_eq!("email.com", address.domain());
+    /// # Ok(())
+    /// # }
+    /// ```
     pub fn domain(&self) -> &str {
         &self.serialized[self.at_start + 1..]
     }
 
-    fn check_user(user: &str) -> Result<(), AddressError> {
+    pub(super) fn check_user(user: &str) -> Result<(), AddressError> {
         if USER_RE.is_match(user) {
             Ok(())
         } else {
@@ -85,7 +150,7 @@ impl Address {
         }
     }
 
-    fn check_domain(domain: &str) -> Result<(), AddressError> {
+    pub(super) fn check_domain(domain: &str) -> Result<(), AddressError> {
         Address::check_domain_ascii(domain).or_else(|_| {
             domain_to_ascii(domain)
                 .map_err(|_| AddressError::InvalidDomain)
@@ -108,10 +173,15 @@ impl Address {
 
         Err(AddressError::InvalidDomain)
     }
+
+    /// Check if the address contains non-ascii chars
+    pub(super) fn is_ascii(&self) -> bool {
+        self.serialized.is_ascii()
+    }
 }
 
 impl Display for Address {
-    fn fmt(&self, f: &mut Formatter) -> FmtResult {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         f.write_str(&self.serialized)
     }
 }
@@ -146,6 +216,7 @@ impl AsRef<OsStr> for Address {
 }
 
 #[derive(Debug, PartialEq, Clone, Copy)]
+/// Errors in email addresses parsing
 pub enum AddressError {
     MissingParts,
     Unbalanced,
@@ -157,7 +228,7 @@ pub enum AddressError {
 impl Error for AddressError {}
 
 impl Display for AddressError {
-    fn fmt(&self, f: &mut Formatter) -> FmtResult {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         match self {
             AddressError::MissingParts => f.write_str("Missing domain or user"),
             AddressError::Unbalanced => f.write_str("Unbalanced angle bracket"),
@@ -168,120 +239,6 @@ impl Display for AddressError {
     }
 }
 
-#[cfg(feature = "serde")]
-mod serde {
-    use crate::address::Address;
-    use serde::{
-        de::{Deserializer, Error as DeError, MapAccess, Visitor},
-        ser::Serializer,
-        Deserialize, Serialize,
-    };
-    use std::fmt::{Formatter, Result as FmtResult};
-
-    impl Serialize for Address {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            serializer.serialize_str(self.as_ref())
-        }
-    }
-
-    impl<'de> Deserialize<'de> for Address {
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            enum Field {
-                User,
-                Domain,
-            };
-
-            const FIELDS: &[&str] = &["user", "domain"];
-
-            impl<'de> Deserialize<'de> for Field {
-                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-                where
-                    D: Deserializer<'de>,
-                {
-                    struct FieldVisitor;
-
-                    impl<'de> Visitor<'de> for FieldVisitor {
-                        type Value = Field;
-
-                        fn expecting(&self, formatter: &mut Formatter) -> FmtResult {
-                            formatter.write_str("'user' or 'domain'")
-                        }
-
-                        fn visit_str<E>(self, value: &str) -> Result<Field, E>
-                        where
-                            E: DeError,
-                        {
-                            match value {
-                                "user" => Ok(Field::User),
-                                "domain" => Ok(Field::Domain),
-                                _ => Err(DeError::unknown_field(value, FIELDS)),
-                            }
-                        }
-                    }
-
-                    deserializer.deserialize_identifier(FieldVisitor)
-                }
-            }
-
-            struct AddressVisitor;
-
-            impl<'de> Visitor<'de> for AddressVisitor {
-                type Value = Address;
-
-                fn expecting(&self, formatter: &mut Formatter) -> FmtResult {
-                    formatter.write_str("email address string or object")
-                }
-
-                fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-                where
-                    E: DeError,
-                {
-                    s.parse().map_err(DeError::custom)
-                }
-
-                fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
-                where
-                    V: MapAccess<'de>,
-                {
-                    let mut user = None;
-                    let mut domain = None;
-                    while let Some(key) = map.next_key()? {
-                        match key {
-                            Field::User => {
-                                if user.is_some() {
-                                    return Err(DeError::duplicate_field("user"));
-                                }
-                                let val = map.next_value()?;
-                                Address::check_user(val).map_err(DeError::custom)?;
-                                user = Some(val);
-                            }
-                            Field::Domain => {
-                                if domain.is_some() {
-                                    return Err(DeError::duplicate_field("domain"));
-                                }
-                                let val = map.next_value()?;
-                                Address::check_domain(val).map_err(DeError::custom)?;
-                                domain = Some(val);
-                            }
-                        }
-                    }
-                    let user: &str = user.ok_or_else(|| DeError::missing_field("user"))?;
-                    let domain: &str = domain.ok_or_else(|| DeError::missing_field("domain"))?;
-                    Ok(Address::new(user, domain).unwrap())
-                }
-            }
-
-            deserializer.deserialize_any(AddressVisitor)
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/error.rs

@@ -1,3 +1,5 @@
+//! Error type for email messages
+
 use std::{
     error::Error as StdError,
     fmt::{self, Display, Formatter},

src/executor.rs

@@ -0,0 +1,232 @@
+use async_trait::async_trait;
+
+#[cfg(feature = "file-transport")]
+use std::io::Result as IoResult;
+#[cfg(feature = "file-transport")]
+use std::path::Path;
+
+#[cfg(all(
+    feature = "smtp-transport",
+    any(feature = "tokio02", feature = "tokio1", feature = "async-std1")
+))]
+use crate::transport::smtp::client::AsyncSmtpConnection;
+#[cfg(all(
+    feature = "smtp-transport",
+    any(feature = "tokio02", feature = "tokio1", feature = "async-std1")
+))]
+use crate::transport::smtp::client::Tls;
+#[cfg(all(
+    feature = "smtp-transport",
+    any(feature = "tokio02", feature = "tokio1", feature = "async-std1")
+))]
+use crate::transport::smtp::extension::ClientId;
+#[cfg(all(
+    feature = "smtp-transport",
+    any(feature = "tokio02", feature = "tokio1", feature = "async-std1")
+))]
+use crate::transport::smtp::Error;
+
+#[async_trait]
+pub trait Executor: Send + Sync + private::Sealed {
+    #[doc(hidden)]
+    #[cfg(feature = "smtp-transport")]
+    async fn connect(
+        hostname: &str,
+        port: u16,
+        hello_name: &ClientId,
+        tls: &Tls,
+    ) -> Result<AsyncSmtpConnection, Error>;
+
+    #[doc(hidden)]
+    #[cfg(feature = "file-transport-envelope")]
+    async fn fs_read(path: &Path) -> IoResult<Vec<u8>>;
+
+    #[doc(hidden)]
+    #[cfg(feature = "file-transport")]
+    async fn fs_write(path: &Path, contents: &[u8]) -> IoResult<()>;
+}
+
+#[allow(missing_copy_implementations)]
+#[non_exhaustive]
+#[cfg(feature = "tokio02")]
+#[cfg_attr(docsrs, doc(cfg(feature = "tokio02")))]
+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
+    }
+}
+
+#[allow(missing_copy_implementations)]
+#[non_exhaustive]
+#[cfg(feature = "tokio1")]
+#[cfg_attr(docsrs, doc(cfg(feature = "tokio1")))]
+pub struct Tokio1Executor;
+
+#[async_trait]
+#[cfg(feature = "tokio1")]
+impl Executor for Tokio1Executor {
+    #[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 = "tokio1-native-tls", feature = "tokio1-rustls-tls"))]
+            Tls::Wrapper(ref tls_parameters) => Some(tls_parameters.clone()),
+            _ => None,
+        };
+        #[allow(unused_mut)]
+        let mut conn =
+            AsyncSmtpConnection::connect_tokio1(hostname, port, hello_name, tls_parameters).await?;
+
+        #[cfg(any(feature = "tokio1-native-tls", feature = "tokio1-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>> {
+        tokio1_crate::fs::read(path).await
+    }
+
+    #[doc(hidden)]
+    #[cfg(feature = "file-transport")]
+    async fn fs_write(path: &Path, contents: &[u8]) -> IoResult<()> {
+        tokio1_crate::fs::write(path, contents).await
+    }
+}
+
+#[allow(missing_copy_implementations)]
+#[non_exhaustive]
+#[cfg(feature = "async-std1")]
+#[cfg_attr(docsrs, doc(cfg(feature = "async-std1")))]
+pub struct AsyncStd1Executor;
+
+#[async_trait]
+#[cfg(feature = "async-std1")]
+impl Executor for AsyncStd1Executor {
+    #[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 = "async-std1-native-tls", feature = "async-std1-rustls-tls"))]
+            Tls::Wrapper(ref tls_parameters) => Some(tls_parameters.clone()),
+            _ => None,
+        };
+        #[allow(unused_mut)]
+        let mut conn =
+            AsyncSmtpConnection::connect_asyncstd1(hostname, port, hello_name, tls_parameters)
+                .await?;
+
+        #[cfg(any(feature = "async-std1-native-tls", feature = "async-std1-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>> {
+        async_std::fs::read(path).await
+    }
+
+    #[doc(hidden)]
+    #[cfg(feature = "file-transport")]
+    async fn fs_write(path: &Path, contents: &[u8]) -> IoResult<()> {
+        async_std::fs::write(path, contents).await
+    }
+}
+
+mod private {
+    use super::*;
+
+    pub trait Sealed {}
+
+    #[cfg(feature = "tokio02")]
+    impl Sealed for Tokio02Executor {}
+
+    #[cfg(feature = "tokio1")]
+    impl Sealed for Tokio1Executor {}
+
+    #[cfg(feature = "async-std1")]
+    impl Sealed for AsyncStd1Executor {}
+}

src/lib.rs

@@ -5,12 +5,13 @@
 //! * Unicode support
 //! * Secure defaults
 //!
-//! Lettre requires Rust 1.40 or newer.
+//! Lettre requires Rust 1.45 or newer.
 //!
 //! ## Optional features
 //!
 //! * **builder**: Message builder
 //! * **file-transport**: Transport that write messages into a file
+//! * **file-transport-envelope**: Allow writing the envelope into a JSON file
 //! * **smtp-transport**: Transport over SMTP
 //! * **sendmail-transport**: Transport over SMTP
 //! * **rustls-tls**: TLS support with the `rustls` crate
@@ -18,192 +19,110 @@
 //! * **tokio02**: Allow to asyncronously send emails using tokio 0.2.x
 //! * **tokio02-rustls-tls**: Async TLS support with the `rustls` crate using tokio 0.2
 //! * **tokio02-native-tls**: Async TLS support with the `native-tls` crate using tokio 0.2
-//! * **async-std1**: Allow to asyncronously send emails using async-std 1.x (SMTP isn't supported yet)
+//! * **tokio1**: Allow to asyncronously send emails using tokio 1.x
+//! * **tokio1-rustls-tls**: Async TLS support with the `rustls` crate using tokio 1.x
+//! * **tokio1-native-tls**: Async TLS support with the `native-tls` crate using tokio 1.x
+//! * **async-std1**: Allow to asynchronously send emails using async-std 1.x
+//! * NOTE: native-tls isn't supported with async-std at the moment
+//! * **async-std1-rustls-tls**: Async TLS support with the `rustls` crate using async-std 1.x
 //! * **r2d2**: Connection pool for SMTP transport
 //! * **tracing**: Logging using the `tracing` crate
 //! * **serde**: Serialization/Deserialization of entities
 //! * **hostname**: Ability to try to use actual hostname in SMTP transaction
 
-#![doc(html_root_url = "https://docs.rs/lettre/0.10.0")]
+#![doc(html_root_url = "https://docs.rs/crate/lettre/0.10.0-beta.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)]
 #![deny(
     missing_copy_implementations,
     trivial_casts,
     trivial_numeric_casts,
     unstable_features,
     unused_import_braces,
-    unsafe_code
+    rust_2018_idioms
 )]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 pub mod address;
 pub mod error;
+#[cfg(all(any(feature = "tokio02", feature = "tokio1", feature = "async-std1")))]
+mod executor;
 #[cfg(feature = "builder")]
+#[cfg_attr(docsrs, doc(cfg(feature = "builder")))]
 pub mod message;
 pub mod transport;
 
-use crate::error::Error;
 #[cfg(feature = "builder")]
-pub use crate::message::{
-    header::{self, Headers},
-    EmailFormat, Mailbox, Mailboxes, Message,
-};
+#[macro_use]
+extern crate hyperx;
+
+#[cfg(feature = "async-std1")]
+pub use self::executor::AsyncStd1Executor;
+#[cfg(all(any(feature = "tokio02", 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")))]
+pub use self::transport::AsyncTransport;
+pub use crate::address::Address;
+#[cfg(feature = "builder")]
+pub use crate::message::Message;
+#[cfg(all(
+    feature = "file-transport",
+    any(feature = "tokio02", feature = "tokio1", feature = "async-std1")
+))]
+pub use crate::transport::file::AsyncFileTransport;
 #[cfg(feature = "file-transport")]
 pub use crate::transport::file::FileTransport;
+#[cfg(all(
+    feature = "sendmail-transport",
+    any(feature = "tokio02", feature = "tokio1", feature = "async-std1")
+))]
+pub use crate::transport::sendmail::AsyncSendmailTransport;
 #[cfg(feature = "sendmail-transport")]
 pub use crate::transport::sendmail::SendmailTransport;
-#[cfg(all(feature = "smtp-transport", feature = "connection-pool"))]
-pub use crate::transport::smtp::r2d2::SmtpConnectionManager;
+#[cfg(all(
+    feature = "smtp-transport",
+    any(feature = "tokio02", feature = "tokio1")
+))]
+pub use crate::transport::smtp::AsyncSmtpTransport;
+pub use crate::transport::Transport;
+use crate::{address::Envelope, error::Error};
+
+#[doc(hidden)]
+#[allow(deprecated)]
+#[cfg(all(feature = "smtp-transport", feature = "async-std1"))]
+pub use crate::transport::smtp::AsyncStd1Connector;
 #[cfg(feature = "smtp-transport")]
 pub use crate::transport::smtp::SmtpTransport;
+#[doc(hidden)]
+#[allow(deprecated)]
 #[cfg(all(feature = "smtp-transport", feature = "tokio02"))]
-pub use crate::transport::smtp::{AsyncSmtpTransport, Tokio02Connector};
-pub use crate::{address::Address, transport::stub::StubTransport};
-#[cfg(any(feature = "async-std1", feature = "tokio02"))]
-use async_trait::async_trait;
-#[cfg(feature = "builder")]
-use std::convert::TryFrom;
-
-/// Simple email envelope representation
-///
-/// We only accept mailboxes, and do not support source routes (as per RFC).
-#[derive(PartialEq, Eq, Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct Envelope {
-    /// The envelope recipients' addresses
-    ///
-    /// This can not be empty.
-    forward_path: Vec<Address>,
-    /// The envelope sender address
-    reverse_path: Option<Address>,
-}
-
-impl Envelope {
-    /// Creates a new envelope, which may fail if `to` is empty.
-    pub fn new(from: Option<Address>, to: Vec<Address>) -> Result<Envelope, Error> {
-        if to.is_empty() {
-            return Err(Error::MissingTo);
-        }
-        Ok(Envelope {
-            forward_path: to,
-            reverse_path: from,
-        })
-    }
-
-    /// Destination addresses of the envelope
-    pub fn to(&self) -> &[Address] {
-        self.forward_path.as_slice()
-    }
-
-    /// Source address of the envelope
-    pub fn from(&self) -> Option<&Address> {
-        self.reverse_path.as_ref()
-    }
-}
-
-impl TryFrom<&Headers> for Envelope {
-    type Error = Error;
-
-    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()),
-            // ... else try From
-            None => match headers.get::<header::From>() {
-                Some(header::From(a)) => {
-                    let from: Vec<Mailbox> = a.clone().into();
-                    if from.len() > 1 {
-                        return Err(Error::TooManyFrom);
-                    }
-                    Some(from[0].email.clone())
-                }
-                None => None,
-            },
-        };
-
-        fn add_addresses_from_mailboxes(
-            addresses: &mut Vec<Address>,
-            mailboxes: Option<&Mailboxes>,
-        ) {
-            if let Some(mailboxes) = mailboxes {
-                for mailbox in mailboxes.iter() {
-                    addresses.push(mailbox.email.clone());
-                }
-            }
-        }
-        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));
-
-        Self::new(from, to)
-    }
-}
-
-/// Blocking Transport method for emails
-pub trait Transport {
-    /// Response produced by the Transport
-    type Ok;
-    /// Error produced by the Transport
-    type Error;
-
-    /// Sends the email
-    #[cfg(feature = "builder")]
-    fn send(&self, message: &Message) -> Result<Self::Ok, Self::Error> {
-        let raw = message.formatted();
-        self.send_raw(message.envelope(), &raw)
-    }
-
-    fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error>;
-}
-
-/// async-std 1.x based Transport method for emails
+pub use crate::transport::smtp::Tokio02Connector;
+#[doc(hidden)]
+#[allow(deprecated)]
+#[cfg(all(feature = "smtp-transport", feature = "tokio1"))]
+pub use crate::transport::smtp::Tokio1Connector;
+#[doc(hidden)]
 #[cfg(feature = "async-std1")]
-#[async_trait]
-pub trait AsyncStd1Transport {
-    /// Response produced by the Transport
-    type Ok;
-    /// Error produced by the Transport
-    type Error;
-
-    /// Sends the email
-    #[cfg(feature = "builder")]
-    // TODO take &Message
-    async fn send(&self, message: Message) -> Result<Self::Ok, Self::Error> {
-        let raw = message.formatted();
-        let envelope = message.envelope();
-        self.send_raw(&envelope, &raw).await
-    }
-
-    async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error>;
-}
-
-/// tokio 0.2.x based Transport method for emails
+pub use crate::transport::AsyncStd1Transport;
+#[doc(hidden)]
 #[cfg(feature = "tokio02")]
-#[async_trait]
-pub trait Tokio02Transport {
-    /// Response produced by the Transport
-    type Ok;
-    /// Error produced by the Transport
-    type Error;
-
-    /// Sends the email
-    #[cfg(feature = "builder")]
-    // TODO take &Message
-    async fn send(&self, message: Message) -> Result<Self::Ok, Self::Error> {
-        let raw = message.formatted();
-        let envelope = message.envelope();
-        self.send_raw(&envelope, &raw).await
-    }
-
-    async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error>;
-}
+pub use crate::transport::Tokio02Transport;
+#[doc(hidden)]
+#[cfg(feature = "tokio1")]
+pub use crate::transport::Tokio1Transport;
 
 #[cfg(test)]
+#[cfg(feature = "builder")]
 mod test {
     use super::*;
     use crate::message::{header, Mailbox, Mailboxes};
     use hyperx::header::Headers;
+    use std::convert::TryFrom;
 
     #[test]
     fn envelope_from_headers() {

src/message/body.rs

@@ -0,0 +1,581 @@
+use std::{
+    io::{self, Write},
+    ops::Deref,
+};
+
+use crate::message::header::ContentTransferEncoding;
+
+/// A [`Message`][super::Message] or [`SinglePart`][super::SinglePart] body that has already been encoded.
+#[derive(Debug, Clone)]
+pub struct Body {
+    buf: Vec<u8>,
+    encoding: ContentTransferEncoding,
+}
+
+/// Either a `Vec<u8>` or a `String`.
+///
+/// If the content is valid utf-8 a `String` should be passed, as it
+/// makes for a more efficient `Content-Transfer-Encoding` to be chosen.
+#[derive(Debug, Clone)]
+pub enum MaybeString {
+    Binary(Vec<u8>),
+    String(String),
+}
+
+impl Body {
+    /// Encode the supplied `buf`, making it ready to be sent as a body.
+    ///
+    /// Takes a `Vec<u8>` or a `String`.
+    ///
+    /// Automatically chooses the most efficient encoding between
+    /// `7bit`, `quoted-printable` and `base64`.
+    ///
+    /// 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 encoding = buf.encoding();
+        Self::new_impl(buf.into(), encoding)
+    }
+
+    /// Encode the supplied `buf`, using the provided `encoding`.
+    ///
+    /// [`Body::new`] is generally the better option.
+    ///
+    /// Returns an [`Err`] giving back the supplied `buf`, in case the chosen
+    /// encoding would have resulted into `buf` being encoded
+    /// into an invalid body.
+    pub fn new_with_encoding<B: Into<MaybeString>>(
+        buf: B,
+        encoding: ContentTransferEncoding,
+    ) -> Result<Self, Vec<u8>> {
+        let buf: MaybeString = buf.into();
+
+        if !buf.is_encoding_ok(encoding) {
+            return Err(buf.into());
+        }
+
+        Ok(Self::new_impl(buf.into(), encoding))
+    }
+
+    /// Builds a new `Body` using a pre-encoded buffer.
+    ///
+    /// **Generally not you want.**
+    ///
+    /// `buf` shouldn't contain non-ascii characters, lines longer than 1000 characters or nul bytes.
+    #[inline]
+    pub fn dangerous_pre_encoded(buf: Vec<u8>, encoding: ContentTransferEncoding) -> Self {
+        Self { buf, encoding }
+    }
+
+    /// Encodes the supplied `buf` using the provided `encoding`
+    fn new_impl(buf: Vec<u8>, encoding: ContentTransferEncoding) -> Self {
+        match encoding {
+            ContentTransferEncoding::SevenBit
+            | ContentTransferEncoding::EightBit
+            | ContentTransferEncoding::Binary => Self { buf, encoding },
+            ContentTransferEncoding::QuotedPrintable => {
+                let encoded = quoted_printable::encode(buf);
+
+                Self::dangerous_pre_encoded(encoded, ContentTransferEncoding::QuotedPrintable)
+            }
+            ContentTransferEncoding::Base64 => {
+                let base64_len = buf.len() * 4 / 3 + 4;
+                let base64_endings_len = base64_len + base64_len / LINE_MAX_LENGTH;
+
+                let mut out = Vec::with_capacity(base64_endings_len);
+                {
+                    let writer = LineWrappingWriter::new(&mut out, LINE_MAX_LENGTH);
+                    let mut writer = base64::write::EncoderWriter::new(writer, base64::STANDARD);
+
+                    // TODO: use writer.write_all(self.as_ref()).expect("base64 encoding never fails");
+
+                    // modified Write::write_all to work around base64 crate bug
+                    // TODO: remove once https://github.com/marshallpierce/rust-base64/issues/148 is fixed
+                    {
+                        let mut buf: &[u8] = buf.as_ref();
+                        while !buf.is_empty() {
+                            match writer.write(buf) {
+                                Ok(0) => {
+                                    // ignore 0 writes
+                                }
+                                Ok(n) => {
+                                    buf = &buf[n..];
+                                }
+                                Err(ref e) if e.kind() == std::io::ErrorKind::Interrupted => {}
+                                Err(e) => panic!("base64 encoding never fails: {}", e),
+                            }
+                        }
+                    }
+                }
+
+                Self::dangerous_pre_encoded(out, ContentTransferEncoding::Base64)
+            }
+        }
+    }
+
+    /// Returns the length of this `Body` in bytes.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.buf.len()
+    }
+
+    /// Returns `true` if this `Body` has a length of zero, `false` otherwise.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.buf.is_empty()
+    }
+
+    /// Returns the `Content-Transfer-Encoding` of this `Body`.
+    #[inline]
+    pub fn encoding(&self) -> ContentTransferEncoding {
+        self.encoding
+    }
+
+    /// Consumes `Body` and returns the inner `Vec<u8>`
+    #[inline]
+    pub fn into_vec(self) -> Vec<u8> {
+        self.buf
+    }
+}
+
+impl MaybeString {
+    /// Suggests the best `Content-Transfer-Encoding` to be used for this `MaybeString`
+    ///
+    /// If the `MaybeString` was created from a `String` composed only of US-ASCII
+    /// characters, with no lines longer than 1000 characters, then 7bit
+    /// encoding will be used, else quoted-printable will be chosen.
+    ///
+    /// If the `MaybeString` was instead created from a `Vec<u8>`, base64 encoding is always
+    /// chosen.
+    ///
+    /// `8bit` and `binary` encodings are never returned, as they may not be
+    /// supported by all SMTP servers.
+    pub fn encoding(&self) -> ContentTransferEncoding {
+        match &self {
+            Self::String(s) if is_7bit_encoded(s.as_ref()) => ContentTransferEncoding::SevenBit,
+            // TODO: consider when base64 would be a better option because of output size
+            Self::String(_) => ContentTransferEncoding::QuotedPrintable,
+            Self::Binary(_) => ContentTransferEncoding::Base64,
+        }
+    }
+
+    /// Returns `true` if using `encoding` to encode this `MaybeString`
+    /// would result into an invalid encoded body.
+    fn is_encoding_ok(&self, encoding: ContentTransferEncoding) -> bool {
+        match encoding {
+            ContentTransferEncoding::SevenBit => is_7bit_encoded(&self),
+            ContentTransferEncoding::EightBit => is_8bit_encoded(&self),
+            ContentTransferEncoding::Binary
+            | ContentTransferEncoding::QuotedPrintable
+            | ContentTransferEncoding::Base64 => true,
+        }
+    }
+}
+
+/// A trait for something that takes an encoded [`Body`].
+///
+/// Used by [`MessageBuilder::body`][super::MessageBuilder::body] and
+/// [`SinglePartBuilder::body`][super::SinglePartBuilder::body],
+/// which can either take something that can be encoded into [`Body`]
+/// or a pre-encoded [`Body`].
+///
+/// If `encoding` is `None` the best encoding between `7bit`, `quoted-printable`
+/// and `base64` is chosen based on the input body. **Best option.**
+///
+/// If `encoding` is `Some` the supplied encoding is used.
+/// **NOTE:** if using the specified `encoding` would result into a malformed
+/// body, this will panic!
+pub trait IntoBody {
+    fn into_body(self, encoding: Option<ContentTransferEncoding>) -> Body;
+}
+
+impl<T> IntoBody for T
+where
+    T: Into<MaybeString>,
+{
+    fn into_body(self, encoding: Option<ContentTransferEncoding>) -> Body {
+        match encoding {
+            Some(encoding) => Body::new_with_encoding(self, encoding).expect("invalid encoding"),
+            None => Body::new(self),
+        }
+    }
+}
+
+impl IntoBody for Body {
+    fn into_body(self, encoding: Option<ContentTransferEncoding>) -> Body {
+        let _ = encoding;
+
+        self
+    }
+}
+
+impl AsRef<[u8]> for Body {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        self.buf.as_ref()
+    }
+}
+
+impl From<Vec<u8>> for MaybeString {
+    #[inline]
+    fn from(b: Vec<u8>) -> Self {
+        Self::Binary(b)
+    }
+}
+
+impl From<String> for MaybeString {
+    #[inline]
+    fn from(s: String) -> Self {
+        Self::String(s)
+    }
+}
+
+impl From<MaybeString> for Vec<u8> {
+    #[inline]
+    fn from(s: MaybeString) -> Self {
+        match s {
+            MaybeString::Binary(b) => b,
+            MaybeString::String(s) => s.into(),
+        }
+    }
+}
+
+impl Deref for MaybeString {
+    type Target = [u8];
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        match self {
+            Self::Binary(b) => b.as_ref(),
+            Self::String(s) => s.as_ref(),
+        }
+    }
+}
+
+/// Checks whether it contains only US-ASCII characters,
+/// and no lines are longer than 1000 characters including the `\n` character.
+///
+/// Most efficient content encoding available
+fn is_7bit_encoded(buf: &[u8]) -> bool {
+    buf.is_ascii() && !contains_too_long_lines(buf)
+}
+
+/// Checks that no lines are longer than 1000 characters,
+/// including the `\n` character.
+/// NOTE: 8bit isn't supported by all SMTP servers.
+fn is_8bit_encoded(buf: &[u8]) -> bool {
+    !contains_too_long_lines(buf)
+}
+
+/// Checks if there are lines that are longer than 1000 characters,
+/// including the `\n` character.
+fn contains_too_long_lines(buf: &[u8]) -> bool {
+    buf.len() > 1000 && buf.split(|&b| b == b'\n').any(|line| line.len() > 999)
+}
+
+const LINE_SEPARATOR: &[u8] = b"\r\n";
+const LINE_MAX_LENGTH: usize = 78 - LINE_SEPARATOR.len();
+
+/// A `Write`r that inserts a line separator `\r\n` every `max_line_length` bytes.
+struct LineWrappingWriter<'a, W> {
+    writer: &'a mut W,
+    current_line_length: usize,
+    max_line_length: usize,
+}
+
+impl<'a, W> LineWrappingWriter<'a, W> {
+    pub fn new(writer: &'a mut W, max_line_length: usize) -> Self {
+        Self {
+            writer,
+            current_line_length: 0,
+            max_line_length,
+        }
+    }
+}
+
+impl<'a, W> Write for LineWrappingWriter<'a, W>
+where
+    W: Write,
+{
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let remaining_line_len = self.max_line_length - self.current_line_length;
+        let write_len = std::cmp::min(buf.len(), remaining_line_len);
+
+        self.writer.write_all(&buf[..write_len])?;
+
+        if remaining_line_len == write_len {
+            self.writer.write_all(LINE_SEPARATOR)?;
+
+            self.current_line_length = 0;
+        } else {
+            self.current_line_length += write_len;
+        }
+
+        Ok(write_len)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.writer.flush()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::{Body, ContentTransferEncoding};
+
+    #[test]
+    fn seven_bit_detect() {
+        let encoded = Body::new(String::from("Hello, world!"));
+
+        assert_eq!(encoded.encoding(), ContentTransferEncoding::SevenBit);
+        assert_eq!(encoded.as_ref(), b"Hello, world!");
+    }
+
+    #[test]
+    fn seven_bit_encode() {
+        let encoded = Body::new_with_encoding(
+            String::from("Hello, world!"),
+            ContentTransferEncoding::SevenBit,
+        )
+        .unwrap();
+
+        assert_eq!(encoded.encoding(), ContentTransferEncoding::SevenBit);
+        assert_eq!(encoded.as_ref(), b"Hello, world!");
+    }
+
+    #[test]
+    fn seven_bit_too_long_detect() {
+        let encoded = Body::new("Hello, world!".repeat(100));
+
+        assert_eq!(encoded.encoding(), ContentTransferEncoding::QuotedPrintable);
+        assert_eq!(
+            encoded.as_ref(),
+            concat!(
+                "Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, wor=\r\n",
+                "ld!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, =\r\n",
+                "world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hell=\r\n",
+                "o, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!H=\r\n",
+                "ello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, worl=\r\n",
+                "d!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, w=\r\n",
+                "orld!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello=\r\n",
+                ", world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!He=\r\n",
+                "llo, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world=\r\n",
+                "!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, wo=\r\n",
+                "rld!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello,=\r\n",
+                " world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hel=\r\n",
+                "lo, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!=\r\n",
+                "Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, wor=\r\n",
+                "ld!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, =\r\n",
+                "world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hell=\r\n",
+                "o, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!H=\r\n",
+                "ello, world!Hello, world!"
+            )
+            .as_bytes()
+        );
+    }
+
+    #[test]
+    fn seven_bit_too_long_fail() {
+        let result = Body::new_with_encoding(
+            "Hello, world!".repeat(100),
+            ContentTransferEncoding::SevenBit,
+        );
+
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn seven_bit_too_long_encode_quotedprintable() {
+        let encoded = Body::new_with_encoding(
+            "Hello, world!".repeat(100),
+            ContentTransferEncoding::QuotedPrintable,
+        )
+        .unwrap();
+
+        assert_eq!(encoded.encoding(), ContentTransferEncoding::QuotedPrintable);
+        assert_eq!(
+            encoded.as_ref(),
+            concat!(
+                "Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, wor=\r\n",
+                "ld!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, =\r\n",
+                "world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hell=\r\n",
+                "o, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!H=\r\n",
+                "ello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, worl=\r\n",
+                "d!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, w=\r\n",
+                "orld!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello=\r\n",
+                ", world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!He=\r\n",
+                "llo, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world=\r\n",
+                "!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, wo=\r\n",
+                "rld!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello,=\r\n",
+                " world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hel=\r\n",
+                "lo, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!=\r\n",
+                "Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, wor=\r\n",
+                "ld!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, =\r\n",
+                "world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!Hell=\r\n",
+                "o, world!Hello, world!Hello, world!Hello, world!Hello, world!Hello, world!H=\r\n",
+                "ello, world!Hello, world!"
+            )
+            .as_bytes()
+        );
+    }
+
+    #[test]
+    fn seven_bit_invalid() {
+        let result = Body::new_with_encoding(
+            String::from("Привет, мир!"),
+            ContentTransferEncoding::SevenBit,
+        );
+
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn eight_bit_encode() {
+        let encoded = Body::new_with_encoding(
+            String::from("Привет, мир!"),
+            ContentTransferEncoding::EightBit,
+        )
+        .unwrap();
+
+        assert_eq!(encoded.encoding(), ContentTransferEncoding::EightBit);
+        assert_eq!(encoded.as_ref(), "Привет, мир!".as_bytes());
+    }
+
+    #[test]
+    fn eight_bit_too_long_fail() {
+        let result = Body::new_with_encoding(
+            "Привет, мир!".repeat(200),
+            ContentTransferEncoding::EightBit,
+        );
+
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn quoted_printable_detect() {
+        let encoded = Body::new(String::from("Привет, мир!"));
+
+        assert_eq!(encoded.encoding(), ContentTransferEncoding::QuotedPrintable);
+        assert_eq!(
+            encoded.as_ref(),
+            b"=D0=9F=D1=80=D0=B8=D0=B2=D0=B5=D1=82, =D0=BC=D0=B8=D1=80!".as_ref()
+        );
+    }
+
+    #[test]
+    fn quoted_printable_encode_ascii() {
+        let encoded = Body::new_with_encoding(
+            String::from("Hello, world!"),
+            ContentTransferEncoding::QuotedPrintable,
+        )
+        .unwrap();
+
+        assert_eq!(encoded.encoding(), ContentTransferEncoding::QuotedPrintable);
+        assert_eq!(encoded.as_ref(), b"Hello, world!");
+    }
+
+    #[test]
+    fn quoted_printable_encode_utf8() {
+        let encoded = Body::new_with_encoding(
+            String::from("Привет, мир!"),
+            ContentTransferEncoding::QuotedPrintable,
+        )
+        .unwrap();
+
+        assert_eq!(encoded.encoding(), ContentTransferEncoding::QuotedPrintable);
+        assert_eq!(
+            encoded.as_ref(),
+            b"=D0=9F=D1=80=D0=B8=D0=B2=D0=B5=D1=82, =D0=BC=D0=B8=D1=80!".as_ref()
+        );
+    }
+
+    #[test]
+    fn quoted_printable_encode_line_wrap() {
+        let encoded = Body::new(String::from("Текст письма в уникоде"));
+
+        assert_eq!(encoded.encoding(), ContentTransferEncoding::QuotedPrintable);
+        assert_eq!(
+            encoded.as_ref(),
+            concat!(
+                "=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",
+                "=D1=83=D0=BD=D0=B8=D0=BA=D0=BE=D0=B4=D0=B5"
+            )
+            .as_bytes()
+        );
+    }
+
+    #[test]
+    fn base64_detect() {
+        let input = Body::new(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+        let encoding = input.encoding();
+        assert_eq!(encoding, ContentTransferEncoding::Base64);
+    }
+
+    #[test]
+    fn base64_encode_bytes() {
+        let encoded = Body::new_with_encoding(
+            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+            ContentTransferEncoding::Base64,
+        )
+        .unwrap();
+
+        assert_eq!(encoded.encoding(), ContentTransferEncoding::Base64);
+        assert_eq!(encoded.as_ref(), b"AAECAwQFBgcICQ==");
+    }
+
+    #[test]
+    fn base64_encode_bytes_wrapping() {
+        let encoded = Body::new_with_encoding(
+            vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9].repeat(20),
+            ContentTransferEncoding::Base64,
+        )
+        .unwrap();
+
+        assert_eq!(encoded.encoding(), ContentTransferEncoding::Base64);
+        assert_eq!(
+            encoded.as_ref(),
+            concat!(
+                "AAECAwQFBgcICQABAgMEBQYHCAkAAQIDBAUGBwgJAAECAwQFBgcICQABAgMEBQYHCAkAAQIDBAUG\r\n",
+                "BwgJAAECAwQFBgcICQABAgMEBQYHCAkAAQIDBAUGBwgJAAECAwQFBgcICQABAgMEBQYHCAkAAQID\r\n",
+                "BAUGBwgJAAECAwQFBgcICQABAgMEBQYHCAkAAQIDBAUGBwgJAAECAwQFBgcICQABAgMEBQYHCAkA\r\n",
+                "AQIDBAUGBwgJAAECAwQFBgcICQABAgMEBQYHCAk="
+            )
+            .as_bytes()
+        );
+    }
+
+    #[test]
+    fn base64_encode_ascii() {
+        let encoded = Body::new_with_encoding(
+            String::from("Hello World!"),
+            ContentTransferEncoding::Base64,
+        )
+        .unwrap();
+
+        assert_eq!(encoded.encoding(), ContentTransferEncoding::Base64);
+        assert_eq!(encoded.as_ref(), b"SGVsbG8gV29ybGQh");
+    }
+
+    #[test]
+    fn base64_encode_ascii_wrapping() {
+        let encoded =
+            Body::new_with_encoding("Hello World!".repeat(20), ContentTransferEncoding::Base64)
+                .unwrap();
+
+        assert_eq!(encoded.encoding(), ContentTransferEncoding::Base64);
+        assert_eq!(
+            encoded.as_ref(),
+            concat!(
+                "SGVsbG8gV29ybGQhSGVsbG8gV29ybGQhSGVsbG8gV29ybGQhSGVsbG8gV29ybGQhSGVsbG8gV29y\r\n",
+                "bGQhSGVsbG8gV29ybGQhSGVsbG8gV29ybGQhSGVsbG8gV29ybGQhSGVsbG8gV29ybGQhSGVsbG8g\r\n",
+                "V29ybGQhSGVsbG8gV29ybGQhSGVsbG8gV29ybGQhSGVsbG8gV29ybGQhSGVsbG8gV29ybGQhSGVs\r\n",
+                "bG8gV29ybGQhSGVsbG8gV29ybGQhSGVsbG8gV29ybGQhSGVsbG8gV29ybGQhSGVsbG8gV29ybGQh\r\n",
+                "SGVsbG8gV29ybGQh"
+            )
+            .as_bytes()
+        );
+    }
+}

src/message/encoder.rs

@@ -1,250 +0,0 @@
-use crate::message::header::ContentTransferEncoding;
-
-/// Encoder trait
-pub trait EncoderCodec: Send {
-    /// Encode all data
-    fn encode(&mut self, input: &[u8]) -> Vec<u8>;
-}
-
-/// 7bit codec
-///
-/// WARNING: Panics when passed non-ascii chars
-struct SevenBitCodec {
-    line_wrapper: EightBitCodec,
-}
-
-impl SevenBitCodec {
-    pub fn new() -> Self {
-        SevenBitCodec {
-            line_wrapper: EightBitCodec::new(),
-        }
-    }
-}
-
-impl EncoderCodec for SevenBitCodec {
-    fn encode(&mut self, input: &[u8]) -> Vec<u8> {
-        assert!(input.is_ascii(), "input must be valid ascii");
-
-        self.line_wrapper.encode(input)
-    }
-}
-
-/// Quoted-Printable codec
-///
-struct QuotedPrintableCodec();
-
-impl QuotedPrintableCodec {
-    pub fn new() -> Self {
-        QuotedPrintableCodec()
-    }
-}
-
-impl EncoderCodec for QuotedPrintableCodec {
-    fn encode(&mut self, input: &[u8]) -> Vec<u8> {
-        quoted_printable::encode(input)
-    }
-}
-
-/// Base64 codec
-///
-struct Base64Codec {
-    line_wrapper: EightBitCodec,
-}
-
-impl Base64Codec {
-    pub fn new() -> Self {
-        Base64Codec {
-            // TODO probably 78, 76 is for qp
-            line_wrapper: EightBitCodec::new().with_limit(78 - 2),
-        }
-    }
-}
-
-impl EncoderCodec for Base64Codec {
-    fn encode(&mut self, input: &[u8]) -> Vec<u8> {
-        self.line_wrapper.encode(base64::encode(input).as_bytes())
-    }
-}
-
-/// 8bit codec
-///
-struct EightBitCodec {
-    max_length: usize,
-}
-
-const DEFAULT_MAX_LINE_LENGTH: usize = 1000 - 2;
-
-impl EightBitCodec {
-    pub fn new() -> Self {
-        EightBitCodec {
-            max_length: DEFAULT_MAX_LINE_LENGTH,
-        }
-    }
-
-    pub fn with_limit(mut self, max_length: usize) -> Self {
-        self.max_length = max_length;
-        self
-    }
-}
-
-impl EncoderCodec for EightBitCodec {
-    fn encode(&mut self, input: &[u8]) -> Vec<u8> {
-        let ending = b"\r\n";
-        let endings_len = input.len() / self.max_length * ending.len();
-        let mut out = Vec::with_capacity(input.len() + endings_len);
-
-        for chunk in input.chunks(self.max_length) {
-            // write the line ending after every chunk, except the last one
-            if !out.is_empty() {
-                out.extend_from_slice(ending);
-            }
-
-            out.extend_from_slice(chunk);
-        }
-
-        out
-    }
-}
-
-/// Binary codec
-///
-struct BinaryCodec;
-
-impl BinaryCodec {
-    pub fn new() -> Self {
-        BinaryCodec
-    }
-}
-
-impl EncoderCodec for BinaryCodec {
-    fn encode(&mut self, input: &[u8]) -> Vec<u8> {
-        input.into()
-    }
-}
-
-pub fn codec(encoding: Option<&ContentTransferEncoding>) -> Box<dyn EncoderCodec> {
-    use self::ContentTransferEncoding::*;
-
-    match encoding {
-        Some(SevenBit) => Box::new(SevenBitCodec::new()),
-        Some(QuotedPrintable) => Box::new(QuotedPrintableCodec::new()),
-        Some(Base64) => Box::new(Base64Codec::new()),
-        Some(EightBit) => Box::new(EightBitCodec::new()),
-        Some(Binary) | None => Box::new(BinaryCodec::new()),
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn seven_bit_encode() {
-        let mut c = SevenBitCodec::new();
-
-        assert_eq!(
-            &String::from_utf8(c.encode("Hello, world!".as_bytes())).unwrap(),
-            "Hello, world!"
-        );
-    }
-
-    #[test]
-    #[should_panic]
-    fn seven_bit_encode_panic() {
-        let mut c = SevenBitCodec::new();
-        c.encode("Hello, мир!".as_bytes());
-    }
-
-    #[test]
-    fn quoted_printable_encode() {
-        let mut c = QuotedPrintableCodec::new();
-
-        assert_eq!(
-            &String::from_utf8(c.encode("Привет, мир!".as_bytes())).unwrap(),
-            "=D0=9F=D1=80=D0=B8=D0=B2=D0=B5=D1=82, =D0=BC=D0=B8=D1=80!"
-        );
-
-        assert_eq!(&String::from_utf8(c.encode("Текст письма в уникоде".as_bytes())).unwrap(),
-                   "=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=D1=83=D0=BD=D0=B8=D0=BA=D0=BE=D0=B4=D0=B5");
-    }
-
-    #[test]
-    fn base64_encode() {
-        let mut c = Base64Codec::new();
-
-        assert_eq!(
-            &String::from_utf8(c.encode("Привет, мир!".as_bytes())).unwrap(),
-            "0J/RgNC40LLQtdGCLCDQvNC40YAh"
-        );
-
-        assert_eq!(
-            &String::from_utf8(c.encode("Текст письма в уникоде подлиннее.".as_bytes())).unwrap(),
-            concat!(
-                "0KLQtdC60YHRgiDQv9C40YHRjNC80LAg0LIg0YPQvdC40LrQ",
-                "vtC00LUg0L/QvtC00LvQuNC90L3Q\r\ntdC1Lg=="
-            )
-        );
-
-        assert_eq!(
-            &String::from_utf8(c.encode(
-                "Ну прямо супер-длинный текст письма в уникоде, который уж точно ну никак не поместиться в 78 байт, как ни крути, я гарантирую.".as_bytes()
-                    )).unwrap(),
-
-                concat!("0J3RgyDQv9GA0Y/QvNC+INGB0YPQv9C10YAt0LTQu9C40L3QvdGL0Lkg0YLQtdC60YHRgiDQv9C4\r\n",
-                        "0YHRjNC80LAg0LIg0YPQvdC40LrQvtC00LUsINC60L7RgtC+0YDRi9C5INGD0LYg0YLQvtGH0L3Q\r\n",
-                        "viDQvdGDINC90LjQutCw0Log0L3QtSDQv9C+0LzQtdGB0YLQuNGC0YzRgdGPINCyIDc4INCx0LDQ\r\n",
-                        "udGCLCDQutCw0Log0L3QuCDQutGA0YPRgtC4LCDRjyDQs9Cw0YDQsNC90YLQuNGA0YPRji4=")
-        );
-        assert_eq!(
-            &String::from_utf8(c.encode(
-                "Ну прямо супер-длинный текст письма в уникоде, который уж точно ну никак не поместиться в 78 байт, как ни крути, я гарантирую это.".as_bytes()
-            )).unwrap(),
-
-                concat!("0J3RgyDQv9GA0Y/QvNC+INGB0YPQv9C10YAt0LTQu9C40L3QvdGL0Lkg0YLQtdC60YHRgiDQv9C4\r\n",
-                        "0YHRjNC80LAg0LIg0YPQvdC40LrQvtC00LUsINC60L7RgtC+0YDRi9C5INGD0LYg0YLQvtGH0L3Q\r\n",
-                        "viDQvdGDINC90LjQutCw0Log0L3QtSDQv9C+0LzQtdGB0YLQuNGC0YzRgdGPINCyIDc4INCx0LDQ\r\n",
-                        "udGCLCDQutCw0Log0L3QuCDQutGA0YPRgtC4LCDRjyDQs9Cw0YDQsNC90YLQuNGA0YPRjiDRjdGC\r\n",
-                        "0L4u")
-        );
-    }
-
-    #[test]
-    fn base64_encodeed() {
-        let mut c = Base64Codec::new();
-
-        assert_eq!(
-            &String::from_utf8(c.encode("Chunk.".as_bytes())).unwrap(),
-            "Q2h1bmsu"
-        );
-    }
-
-    #[test]
-    fn eight_bit_encode() {
-        let mut c = EightBitCodec::new();
-
-        assert_eq!(
-            &String::from_utf8(c.encode("Hello, world!".as_bytes())).unwrap(),
-            "Hello, world!"
-        );
-
-        assert_eq!(
-            &String::from_utf8(c.encode("Hello, мир!".as_bytes())).unwrap(),
-            "Hello, мир!"
-        );
-    }
-
-    #[test]
-    fn binary_encode() {
-        let mut c = BinaryCodec::new();
-
-        assert_eq!(
-            &String::from_utf8(c.encode("Hello, world!".as_bytes())).unwrap(),
-            "Hello, world!"
-        );
-
-        assert_eq!(
-            &String::from_utf8(c.encode("Hello, мир!".as_bytes())).unwrap(),
-            "Hello, мир!"
-        );
-    }
-}

src/message/header/content.rs

@@ -7,6 +7,16 @@ use std::{
     str::{from_utf8, FromStr},
 };
 
+header! {
+    /// `Content-Id` header, defined in [RFC2045](https://tools.ietf.org/html/rfc2045#section-7)
+    (ContentId, "Content-ID") => [String]
+}
+
+/// `Content-Transfer-Encoding` of the body
+///
+/// The `Message` builder takes care of choosing the most
+/// efficient encoding based on the chosen body, so in most
+/// use-caches this header shouldn't be set manually.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum ContentTransferEncoding {
     SevenBit,
@@ -19,19 +29,18 @@ pub enum ContentTransferEncoding {
 
 impl Default for ContentTransferEncoding {
     fn default() -> Self {
-        ContentTransferEncoding::SevenBit
+        ContentTransferEncoding::Base64
     }
 }
 
 impl Display for ContentTransferEncoding {
-    fn fmt(&self, f: &mut FmtFormatter) -> FmtResult {
-        use self::ContentTransferEncoding::*;
+    fn fmt(&self, f: &mut FmtFormatter<'_>) -> FmtResult {
         f.write_str(match *self {
-            SevenBit => "7bit",
-            QuotedPrintable => "quoted-printable",
-            Base64 => "base64",
-            EightBit => "8bit",
-            Binary => "binary",
+            Self::SevenBit => "7bit",
+            Self::QuotedPrintable => "quoted-printable",
+            Self::Base64 => "base64",
+            Self::EightBit => "8bit",
+            Self::Binary => "binary",
         })
     }
 }
@@ -39,13 +48,12 @@ impl Display for ContentTransferEncoding {
 impl FromStr for ContentTransferEncoding {
     type Err = String;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        use self::ContentTransferEncoding::*;
         match s {
-            "7bit" => Ok(SevenBit),
-            "quoted-printable" => Ok(QuotedPrintable),
-            "base64" => Ok(Base64),
-            "8bit" => Ok(EightBit),
-            "binary" => Ok(Binary),
+            "7bit" => Ok(Self::SevenBit),
+            "quoted-printable" => Ok(Self::QuotedPrintable),
+            "base64" => Ok(Self::Base64),
+            "8bit" => Ok(Self::EightBit),
+            "binary" => Ok(Self::Binary),
             _ => Err(s.into()),
         }
     }
@@ -71,7 +79,7 @@ impl Header for ContentTransferEncoding {
             })
     }
 
-    fn fmt_header(&self, f: &mut HeaderFormatter) -> FmtResult {
+    fn fmt_header(&self, f: &mut HeaderFormatter<'_, '_>) -> FmtResult {
         f.fmt_line(&format!("{}", self))
     }
 }

src/message/header/mailbox.rs

@@ -35,7 +35,7 @@ macro_rules! mailbox_header {
                     }).map($type_name)
             }
 
-            fn fmt_header(&self, f: &mut HeaderFormatter) -> FmtResult {
+            fn fmt_header(&self, f: &mut HeaderFormatter<'_, '_>) -> FmtResult {
                 f.fmt_line(&self.0.recode_name(utf8_b::encode))
             }
         }
@@ -70,7 +70,7 @@ macro_rules! mailboxes_header {
                     .map($type_name)
             }
 
-            fn fmt_header(&self, f: &mut HeaderFormatter) -> FmtResult {
+            fn fmt_header(&self, f: &mut HeaderFormatter<'_, '_>) -> FmtResult {
                 format_mailboxes(self.0.iter(), f)
             }
         }
@@ -155,7 +155,7 @@ fn parse_mailboxes(raw: &[u8]) -> HyperResult<Mailboxes> {
     Err(HeaderError::Header)
 }
 
-fn format_mailboxes<'a>(mbs: Iter<'a, Mailbox>, f: &mut HeaderFormatter) -> FmtResult {
+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<_>>(),

src/message/header/mod.rs

@@ -1,8 +1,4 @@
-/*!
-
-## Headers widely used in email messages
-
-*/
+//! Headers widely used in email messages
 
 mod content;
 mod mailbox;

src/message/header/special.rs

@@ -5,6 +5,7 @@ use hyperx::{
 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)
 pub struct MimeVersion {
     pub major: u8,
     pub minor: u8,
@@ -45,7 +46,7 @@ impl Header for MimeVersion {
         })
     }
 
-    fn fmt_header(&self, f: &mut HeaderFormatter) -> FmtResult {
+    fn fmt_header(&self, f: &mut HeaderFormatter<'_, '_>) -> FmtResult {
         f.fmt_line(&format!("{}.{}", self.major, self.minor))
     }
 }

src/message/header/textual.rs

@@ -6,8 +6,9 @@ use hyperx::{
 use std::{fmt::Result as FmtResult, str::from_utf8};
 
 macro_rules! text_header {
-    ( $type_name: ident, $header_name: expr ) => {
+    ($(#[$attr:meta])* Header($type_name: ident, $header_name: expr )) => {
         #[derive(Debug, Clone, PartialEq)]
+        $(#[$attr])*
         pub struct $type_name(pub String);
 
         impl Header for $type_name {
@@ -26,20 +27,48 @@ macro_rules! text_header {
                     .map($type_name)
             }
 
-            fn fmt_header(&self, f: &mut HeaderFormatter) -> FmtResult {
+            fn fmt_header(&self, f: &mut HeaderFormatter<'_, '_>) -> FmtResult {
                 fmt_text(&self.0, f)
             }
         }
     };
 }
 
-text_header!(Subject, "Subject");
-text_header!(Comments, "Comments");
-text_header!(Keywords, "Keywords");
-text_header!(InReplyTo, "In-Reply-To");
-text_header!(References, "References");
-text_header!(MessageId, "Message-Id");
-text_header!(UserAgent, "User-Agent");
+text_header!(
+    /// `Subject` of the message, defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.5)
+    Header(Subject, "Subject")
+);
+text_header!(
+    /// `Comments` of the message, defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.5)
+    Header(Comments, "Comments")
+);
+text_header!(
+    /// `Keywords` header. Should contain a comma-separated list of one or more
+    /// words or quoted-strings, defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.5)
+    Header(Keywords, "Keywords")
+);
+text_header!(
+    /// `In-Reply-To` header. Contains one or more
+    /// unique message identifiers,
+    /// defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.4)
+    Header(InReplyTo, "In-Reply-To")
+);
+text_header!(
+    /// `References` header. Contains one or more
+    /// unique message identifiers,
+    /// defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.4)
+    Header(References, "References")
+);
+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")
+);
+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) {
@@ -50,7 +79,7 @@ fn parse_text(raw: &[u8]) -> HyperResult<String> {
     Err(HeaderError::Header)
 }
 
-fn fmt_text(s: &str, f: &mut HeaderFormatter) -> FmtResult {
+fn fmt_text(s: &str, f: &mut HeaderFormatter<'_, '_>) -> FmtResult {
     f.fmt_line(&utf8_b::encode(s))
 }
 

src/message/mailbox/serde.rs

@@ -23,7 +23,7 @@ impl<'de> Deserialize<'de> for Mailbox {
         enum Field {
             Name,
             Email,
-        };
+        }
 
         const FIELDS: &[&str] = &["name", "email"];
 
@@ -37,7 +37,7 @@ impl<'de> Deserialize<'de> for Mailbox {
                 impl<'de> Visitor<'de> for FieldVisitor {
                     type Value = Field;
 
-                    fn expecting(&self, formatter: &mut Formatter) -> FmtResult {
+                    fn expecting(&self, formatter: &mut Formatter<'_>) -> FmtResult {
                         formatter.write_str("'name' or 'email'")
                     }
 
@@ -62,7 +62,7 @@ impl<'de> Deserialize<'de> for Mailbox {
         impl<'de> Visitor<'de> for MailboxVisitor {
             type Value = Mailbox;
 
-            fn expecting(&self, formatter: &mut Formatter) -> FmtResult {
+            fn expecting(&self, formatter: &mut Formatter<'_>) -> FmtResult {
                 formatter.write_str("mailbox string or object")
             }
 
@@ -123,7 +123,7 @@ impl<'de> Deserialize<'de> for Mailboxes {
         impl<'de> Visitor<'de> for MailboxesVisitor {
             type Value = Mailboxes;
 
-            fn expecting(&self, formatter: &mut Formatter) -> FmtResult {
+            fn expecting(&self, formatter: &mut Formatter<'_>) -> FmtResult {
                 formatter.write_str("mailboxes string or sequence")
             }
 

src/message/mailbox/types.rs

@@ -9,22 +9,60 @@ use std::{
     str::FromStr,
 };
 
-/// Email address with optional addressee name
+/// Represents an email address with an optional name for the sender/recipient.
 ///
 /// This type contains email address and the sender/recipient name (_Some Name \<user@domain.tld\>_ or _withoutname@domain.tld_).
 ///
 /// **NOTE**: Enable feature "serde" to be able serialize/deserialize it using [serde](https://serde.rs/).
+///
+/// # Examples
+///
+/// You can create a `Mailbox` from a string and an [`Address`]:
+///
+/// ```
+/// # use lettre::{Address, message::Mailbox};
+/// # use std::error::Error;
+/// # fn main() -> Result<(), Box<dyn Error>> {
+/// let address = Address::new("example", "email.com")?;
+/// let mailbox = Mailbox::new(None, address);
+/// # Ok(())
+/// # }
+/// ```
+///
+/// You can also create one from a string literal:
+///
+/// ```
+/// # use lettre::message::Mailbox;
+/// # use std::error::Error;
+/// # fn main() -> Result<(), Box<dyn Error>> {
+/// let mailbox: Mailbox = "John Smith <example@email.com>".parse()?;
+/// # Ok(())
+/// # }
+/// ```
 #[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
 pub struct Mailbox {
-    /// User name part
+    /// The name associated with the address.
     pub name: Option<String>,
 
-    /// Email address part
+    /// The email address itself.
     pub email: Address,
 }
 
 impl Mailbox {
-    /// Create new mailbox using email address and addressee name
+    /// Creates a new `Mailbox` using an email address and the name of the recipient if there is one.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lettre::{message::Mailbox, Address};
+    ///
+    /// # use std::error::Error;
+    /// # fn main() -> Result<(), Box<dyn Error>> {
+    /// let address = Address::new("example", "email.com")?;
+    /// let mailbox = Mailbox::new(None, address);
+    /// # Ok(())
+    /// # }
+    /// ```
     pub fn new(name: Option<String>, email: Address) -> Self {
         Mailbox { name, email }
     }
@@ -39,7 +77,7 @@ impl Mailbox {
 }
 
 impl Display for Mailbox {
-    fn fmt(&self, f: &mut Formatter) -> FmtResult {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         if let Some(ref name) = self.name {
             let name = name.trim();
             if !name.is_empty() {
@@ -99,7 +137,7 @@ impl FromStr for Mailbox {
     }
 }
 
-/// List or email mailboxes
+/// Represents a sequence of [`Mailbox`] instances.
 ///
 /// This type contains a sequence of mailboxes (_Some Name \<user@domain.tld\>, Another Name \<other@domain.tld\>, withoutname@domain.tld, ..._).
 ///
@@ -108,29 +146,119 @@ impl FromStr for Mailbox {
 pub struct Mailboxes(Vec<Mailbox>);
 
 impl Mailboxes {
-    /// Create mailboxes list
+    /// Creates a new list of [`Mailbox`] instances.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lettre::message::Mailboxes;
+    /// let mailboxes = Mailboxes::new();
+    /// ```
     pub fn new() -> Self {
         Mailboxes(Vec::new())
     }
 
-    /// Add mailbox to a list
+    /// Adds a new [`Mailbox`] to the list, in a builder style pattern.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lettre::{
+    ///     message::{Mailbox, Mailboxes},
+    ///     Address,
+    /// };
+    ///
+    /// # use std::error::Error;
+    /// # fn main() -> Result<(), Box<dyn Error>> {
+    /// let address = Address::new("example", "email.com")?;
+    /// let mut mailboxes = Mailboxes::new().with(Mailbox::new(None, address));
+    /// # Ok(())
+    /// # }
+    /// ```
     pub fn with(mut self, mbox: Mailbox) -> Self {
         self.0.push(mbox);
         self
     }
 
-    /// Add mailbox to a list
+    /// Adds a new [`Mailbox`] to the list, in a Vec::push style pattern.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lettre::{
+    ///     message::{Mailbox, Mailboxes},
+    ///     Address,
+    /// };
+    ///
+    /// # use std::error::Error;
+    /// # fn main() -> Result<(), Box<dyn Error>> {
+    /// let address = Address::new("example", "email.com")?;
+    /// let mut mailboxes = Mailboxes::new();
+    /// mailboxes.push(Mailbox::new(None, address));
+    /// # Ok(())
+    /// # }
+    /// ```
     pub fn push(&mut self, mbox: Mailbox) {
         self.0.push(mbox);
     }
 
-    /// Extract first mailbox
+    /// Extracts the first [`Mailbox`] if it exists.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lettre::{
+    ///     message::{Mailbox, Mailboxes},
+    ///     Address,
+    /// };
+    ///
+    /// # use std::error::Error;
+    /// # fn main() -> Result<(), Box<dyn Error>> {
+    /// let empty = Mailboxes::new();
+    /// assert!(empty.into_single().is_none());
+    ///
+    /// let mut mailboxes = Mailboxes::new();
+    /// let address = Address::new("example", "email.com")?;
+    ///
+    /// mailboxes.push(Mailbox::new(None, address));
+    /// assert!(mailboxes.into_single().is_some());
+    /// # Ok(())
+    /// # }
+    /// ```
     pub fn into_single(self) -> Option<Mailbox> {
         self.into()
     }
 
-    /// Iterate over mailboxes
-    pub fn iter(&self) -> Iter<Mailbox> {
+    /// Creates an iterator over the [`Mailbox`] instances that are currently stored.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use lettre::{
+    ///     message::{Mailbox, Mailboxes},
+    ///     Address,
+    /// };
+    ///
+    /// # use std::error::Error;
+    /// # fn main() -> Result<(), Box<dyn Error>> {
+    /// let mut mailboxes = Mailboxes::new();
+    ///
+    /// let address = Address::new("example", "email.com")?;
+    /// mailboxes.push(Mailbox::new(None, address));
+    ///
+    /// let address = Address::new("example", "email.com")?;
+    /// mailboxes.push(Mailbox::new(None, address));
+    ///
+    /// let mut iter = mailboxes.iter();
+    ///
+    /// assert!(iter.next().is_some());
+    /// assert!(iter.next().is_some());
+    ///
+    /// assert!(iter.next().is_none());
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn iter(&self) -> Iter<'_, Mailbox> {
         self.0.iter()
     }
 }
@@ -142,26 +270,26 @@ impl Default for Mailboxes {
 }
 
 impl From<Mailbox> for Mailboxes {
-    fn from(single: Mailbox) -> Self {
-        Mailboxes(vec![single])
+    fn from(mailbox: Mailbox) -> Self {
+        Mailboxes(vec![mailbox])
     }
 }
 
-impl Into<Option<Mailbox>> for Mailboxes {
-    fn into(self) -> Option<Mailbox> {
-        self.into_iter().next()
+impl From<Mailboxes> for Option<Mailbox> {
+    fn from(mailboxes: Mailboxes) -> Option<Mailbox> {
+        mailboxes.into_iter().next()
     }
 }
 
 impl From<Vec<Mailbox>> for Mailboxes {
-    fn from(list: Vec<Mailbox>) -> Self {
-        Mailboxes(list)
+    fn from(vec: Vec<Mailbox>) -> Self {
+        Mailboxes(vec)
     }
 }
 
-impl Into<Vec<Mailbox>> for Mailboxes {
-    fn into(self) -> Vec<Mailbox> {
-        self.0
+impl From<Mailboxes> for Vec<Mailbox> {
+    fn from(mailboxes: Mailboxes) -> Vec<Mailbox> {
+        mailboxes.0
     }
 }
 
@@ -183,7 +311,7 @@ impl Extend<Mailbox> for Mailboxes {
 }
 
 impl Display for Mailboxes {
-    fn fmt(&self, f: &mut Formatter) -> FmtResult {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         let mut iter = self.iter();
 
         if let Some(mbox) = iter.next() {

src/message/mimebody.rs

@@ -1,21 +1,17 @@
 use crate::message::{
-    encoder::codec,
     header::{ContentTransferEncoding, ContentType, Header, Headers},
-    EmailFormat,
+    EmailFormat, IntoBody,
 };
 use mime::Mime;
 use rand::Rng;
 
 /// MIME part variants
-///
 #[derive(Debug, Clone)]
 pub enum Part {
     /// Single part with content
-    ///
     Single(SinglePart),
 
     /// Multiple parts of content
-    ///
     Multi(MultiPart),
 }
 
@@ -38,11 +34,9 @@ impl Part {
 }
 
 /// Parts of multipart body
-///
 pub type Parts = Vec<Part>;
 
 /// Creates builder for single part
-///
 #[derive(Debug, Clone)]
 pub struct SinglePartBuilder {
     headers: Headers,
@@ -69,10 +63,15 @@ impl SinglePartBuilder {
     }
 
     /// Build singlepart using body
-    pub fn body<T: Into<Vec<u8>>>(self, body: T) -> SinglePart {
+    pub fn body<T: IntoBody>(mut self, body: T) -> SinglePart {
+        let maybe_encoding = self.headers.get::<ContentTransferEncoding>().copied();
+        let body = body.into_body(maybe_encoding);
+
+        self.headers.set(body.encoding());
+
         SinglePart {
             headers: self.headers,
-            body: body.into(),
+            body: body.into_vec(),
         }
     }
 }
@@ -88,14 +87,16 @@ impl Default for SinglePartBuilder {
 /// # Example
 ///
 /// ```
-/// use lettre::message::{SinglePart, header};
+/// use lettre::message::{header, SinglePart};
 ///
+/// # use std::error::Error;
+/// # fn main() -> Result<(), Box<dyn Error>> {
 /// let part = SinglePart::builder()
-///      .header(header::ContentType("text/plain; charset=utf8".parse().unwrap()))
-///      .header(header::ContentTransferEncoding::Binary)
-///      .body("Текст письма в уникоде");
+///     .header(header::ContentType("text/plain; charset=utf8".parse()?))
+///     .body(String::from("Текст письма в уникоде"));
+/// # Ok(())
+/// # }
 /// ```
-///
 #[derive(Debug, Clone)]
 pub struct SinglePart {
     headers: Headers,
@@ -103,57 +104,25 @@ pub struct SinglePart {
 }
 
 impl SinglePart {
-    /// Creates a default builder for singlepart
+    /// Creates a builder for singlepart
+    #[inline]
     pub fn builder() -> SinglePartBuilder {
         SinglePartBuilder::new()
     }
 
-    /// Creates a singlepart builder with 7bit encoding
-    ///
-    /// Shortcut for `SinglePart::builder().header(ContentTransferEncoding::SevenBit)`.
-    pub fn seven_bit() -> SinglePartBuilder {
-        Self::builder().header(ContentTransferEncoding::SevenBit)
-    }
-
-    /// Creates a singlepart builder with quoted-printable encoding
-    ///
-    /// Shortcut for `SinglePart::builder().header(ContentTransferEncoding::QuotedPrintable)`.
-    pub fn quoted_printable() -> SinglePartBuilder {
-        Self::builder().header(ContentTransferEncoding::QuotedPrintable)
-    }
-
-    /// Creates a singlepart builder with base64 encoding
-    ///
-    /// Shortcut for `SinglePart::builder().header(ContentTransferEncoding::Base64)`.
-    pub fn base64() -> SinglePartBuilder {
-        Self::builder().header(ContentTransferEncoding::Base64)
-    }
-
-    /// Creates a singlepart builder with 8-bit encoding
-    ///
-    /// Shortcut for `SinglePart::builder().header(ContentTransferEncoding::EightBit)`.
-    pub fn eight_bit() -> SinglePartBuilder {
-        Self::builder().header(ContentTransferEncoding::EightBit)
-    }
-
-    /// Creates a singlepart builder with binary encoding
-    ///
-    /// Shortcut for `SinglePart::builder().header(ContentTransferEncoding::Binary)`.
-    pub fn binary() -> SinglePartBuilder {
-        Self::builder().header(ContentTransferEncoding::Binary)
-    }
-
     /// Get the headers from singlepart
+    #[inline]
     pub fn headers(&self) -> &Headers {
         &self.headers
     }
 
-    /// Read the body from singlepart
-    pub fn body_ref(&self) -> &[u8] {
+    /// Get the encoded body
+    #[inline]
+    pub fn raw_body(&self) -> &[u8] {
         &self.body
     }
 
-    /// Get message content formatted for SMTP
+    /// Get message content formatted for sending
     pub fn formatted(&self) -> Vec<u8> {
         let mut out = Vec::new();
         self.format(&mut out);
@@ -165,17 +134,12 @@ impl EmailFormat for SinglePart {
     fn format(&self, out: &mut Vec<u8>) {
         out.extend_from_slice(self.headers.to_string().as_bytes());
         out.extend_from_slice(b"\r\n");
-
-        let encoding = self.headers.get::<ContentTransferEncoding>();
-        let mut encoder = codec(encoding);
-
-        out.extend_from_slice(&encoder.encode(&self.body));
+        out.extend_from_slice(&self.body);
         out.extend_from_slice(b"\r\n");
     }
 }
 
 /// The kind of multipart
-///
 #[derive(Debug, Clone)]
 pub enum MultiPartKind {
     /// Mixed kind to combine unrelated content parts
@@ -203,8 +167,9 @@ pub enum MultiPartKind {
 /// Create a random MIME boundary.
 fn make_boundary() -> String {
     rand::thread_rng()
-        .sample_iter(&rand::distributions::Alphanumeric)
-        .take(68)
+        .sample_iter(rand::distributions::Alphanumeric)
+        .take(40)
+        .map(char::from)
         .collect()
 }
 
@@ -261,7 +226,6 @@ impl From<MultiPartKind> for Mime {
 }
 
 /// Multipart builder
-///
 #[derive(Debug, Clone)]
 pub struct MultiPartBuilder {
     headers: Headers,
@@ -327,7 +291,6 @@ impl Default for MultiPartBuilder {
 }
 
 /// Multipart variant with parts
-///
 #[derive(Debug, Clone)]
 pub struct MultiPart {
     headers: Headers,
@@ -535,7 +498,7 @@ mod test {
                         parameters: vec![header::DispositionParam::Filename(
                             header::Charset::Ext("utf-8".into()),
                             None,
-                            "example.c".as_bytes().into(),
+                            "example.c".into(),
                         )],
                     })
                     .header(header::ContentTransferEncoding::Binary)
@@ -582,7 +545,7 @@ mod test {
                         parameters: vec![header::DispositionParam::Filename(
                             header::Charset::Ext("utf-8".into()),
                             None,
-                            "encrypted.asc".as_bytes().into(),
+                            "encrypted.asc".into(),
                         )],
                     })
                     .body(String::from(concat!(
@@ -600,11 +563,13 @@ mod test {
                            "\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",
@@ -637,7 +602,7 @@ mod test {
                     parameters: vec![header::DispositionParam::Filename(
                         header::Charset::Ext("utf-8".into()),
                         None,
-                        "signature.asc".as_bytes().into(),
+                        "signature.asc".into(),
                     )],
                 })
                 .body(String::from(concat!(
@@ -659,11 +624,13 @@ mod test {
                            "\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",
@@ -725,7 +692,7 @@ mod test {
                              .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".as_bytes().into())]
+                                 parameters: vec![header::DispositionParam::Filename(header::Charset::Ext("utf-8".into()), None, "example.c".into())]
                              })
                              .header(header::ContentTransferEncoding::Binary)
                              .body(String::from("int main() { return 0; }")));
@@ -773,7 +740,7 @@ mod test {
 
         // Ensure correct length
         for boundary in boundaries {
-            assert_eq!(68, boundary.len());
+            assert_eq!(40, boundary.len());
         }
     }
 }

src/message/mod.rs

@@ -1,67 +1,98 @@
 //! Provides a strongly typed way to build emails
 //!
-//! ### Creating messages
-//!
-//! This section explains how to create emails.
-//!
 //! ## Usage
 //!
-//! ### Format email messages
+//! This section demonstrates how to build messages.
 //!
-//! #### With string body
+//! <!--
+//! style for <details><summary>Blablabla</summary> Lots of stuff</details>
+//! borrowed from https://docs.rs/time/0.2.23/src/time/lib.rs.html#49-54
+//! -->
+//! <style>
+//! summary, details:not([open]) { cursor: pointer; }
+//! summary { display: list-item; }
+//! summary::marker { content: '▶ '; }
+//! details[open] summary::marker { content: '▼ '; }
+//! </style>
 //!
-//! The easiest way how we can create email message with simple string.
+//!
+//! ### Plain body
+//!
+//! The easiest way of creating a message, which uses a plain text body.
 //!
 //! ```rust
 //! use lettre::message::Message;
 //!
+//! # use std::error::Error;
+//! # fn main() -> Result<(), Box<dyn Error>> {
 //! let m = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse().unwrap())
-//!     .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-//!     .to("Hei <hei@domain.tld>".parse().unwrap())
+//!     .from("NoBody <nobody@domain.tld>".parse()?)
+//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
+//!     .to("Hei <hei@domain.tld>".parse()?)
 //!     .subject("Happy new year")
-//!     .body("Be happy!")
-//!     .unwrap();
+//!     .body(String::from("Be happy!"))?;
+//! # Ok(())
+//! # }
 //! ```
 //!
-//! Will produce:
+//! Which produces:
+//! <details>
+//! <summary>Click to expand</summary>
 //!
 //! ```sh
 //! From: NoBody <nobody@domain.tld>
 //! Reply-To: Yuin <yuin@domain.tld>
 //! To: Hei <hei@domain.tld>
 //! Subject: Happy new year
+//! Date: Sat, 12 Dec 2020 16:33:19 GMT
+//! Content-Transfer-Encoding: 7bit
 //!
 //! Be happy!
 //! ```
+//! </details>
+//! <br />
 //!
-//! The unicode header data will be encoded using _UTF8-Base64_ encoding.
+//! The unicode header data is encoded using _UTF8-Base64_ encoding, when necessary.
 //!
-//! ### With MIME body
+//! The `Content-Transfer-Encoding` is chosen based on the best encoding
+//! available for the given body, between `7bit`, `quoted-printable` and `base64`.
 //!
-//! ##### Single part
+//! ### Plain and HTML body
 //!
-//! The more complex way is using MIME contents.
+//! Uses a MIME body to include both plain text and HTML versions of the body.
 //!
 //! ```rust
-//! use lettre::message::{header, Message, SinglePart, Part};
+//! # use std::error::Error;
+//! use lettre::message::{header, Message, MultiPart, Part, SinglePart};
 //!
+//! # fn main() -> Result<(), Box<dyn Error>> {
 //! let m = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse().unwrap())
-//!     .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-//!     .to("Hei <hei@domain.tld>".parse().unwrap())
+//!     .from("NoBody <nobody@domain.tld>".parse()?)
+//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
+//!     .to("Hei <hei@domain.tld>".parse()?)
 //!     .subject("Happy new year")
-//!     .singlepart(
-//!         SinglePart::builder()
-//!             .header(header::ContentType(
-//!                 "text/plain; charset=utf8".parse().unwrap(),
-//!             )).header(header::ContentTransferEncoding::QuotedPrintable)
-//!             .body("Привет, мир!"),
-//!     )
-//!     .unwrap();
+//!     .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>",
+//!                     )),
+//!             ),
+//!     )?;
+//! # Ok(())
+//! # }
 //! ```
 //!
-//! The body will be encoded using selected `Content-Transfer-Encoding`.
+//! Which produces:
+//! <details>
+//! <summary>Click to expand</summary>
 //!
 //! ```sh
 //! From: NoBody <nobody@domain.tld>
@@ -69,133 +100,170 @@
 //! To: Hei <hei@domain.tld>
 //! Subject: Happy new year
 //! MIME-Version: 1.0
+//! Date: Sat, 12 Dec 2020 16:33:19 GMT
+//! Content-Type: multipart/alternative; boundary="0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1"
+//!
+//! --0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1
 //! Content-Type: text/plain; charset=utf8
-//! Content-Transfer-Encoding: quoted-printable
+//! Content-Transfer-Encoding: 7bit
 //!
-//! =D0=9F=D1=80=D0=B8=D0=B2=D0=B5=D1=82, =D0=BC=D0=B8=D1=80!
+//! Hello, world! :)
+//! --0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1
+//! Content-Type: text/html; charset=utf8
+//! Content-Transfer-Encoding: 7bit
 //!
+//! <p><b>Hello</b>, <i>world</i>! <img src="cid:123"></p>
+//! --0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1--
 //! ```
+//! </details>
 //!
-//! ##### Multiple parts
+//! ### Complex MIME body
 //!
-//! And more advanced way of building message by using multipart MIME contents.
+//! This example shows how to include both plain and HTML versions of the body,
+//! attachments and inlined images.
 //!
 //! ```rust
-//! use lettre::message::{header, Message, MultiPart, SinglePart, Part};
+//! # use std::error::Error;
+//! use lettre::message::{header, Body, Message, MultiPart, Part, SinglePart};
+//! use std::fs;
+//!
+//! # fn main() -> Result<(), Box<dyn Error>> {
+//! let image = fs::read("docs/lettre.png")?;
+//! // this image_body can be cloned and reused between emails.
+//! // since `Body` holds a pre-encoded body, reusing it means avoiding having
+//! // to re-encode the same body for every email (this clearly only applies
+//! // when sending multiple emails with the same attachment).
+//! let image_body = Body::new(image);
 //!
 //! let m = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse().unwrap())
-//!     .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-//!     .to("Hei <hei@domain.tld>".parse().unwrap())
+//!     .from("NoBody <nobody@domain.tld>".parse()?)
+//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
+//!     .to("Hei <hei@domain.tld>".parse()?)
 //!     .subject("Happy new year")
 //!     .multipart(
 //!         MultiPart::mixed()
-//!         .multipart(
-//!             MultiPart::alternative()
-//!             .singlepart(
-//!                 SinglePart::quoted_printable()
-//!                 .header(header::ContentType("text/plain; charset=utf8".parse().unwrap()))
-//!                 .body("Привет, мир!")
-//!             )
 //!             .multipart(
-//!                MultiPart::related()
-//!                 .singlepart(
-//!                     SinglePart::eight_bit()
-//!                     .header(header::ContentType("text/html; charset=utf8".parse().unwrap()))
-//!                     .body("<p><b>Hello</b>, <i>world</i>! <img src=smile.png></p>")
-//!                 )
-//!                 .singlepart(
-//!                     SinglePart::base64()
-//!                     .header(header::ContentType("image/png".parse().unwrap()))
-//!                     .header(header::ContentDisposition {
-//!                         disposition: header::DispositionType::Inline,
-//!                         parameters: vec![],
-//!                     })
-//!                     .body("<smile-raw-image-data>")
-//!                 )
-//!             )
-//!         )
-//!         .singlepart(
-//!             SinglePart::seven_bit()
-//!             .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".as_bytes().into()
+//!                 MultiPart::alternative()
+//!                     .singlepart(
+//!                         SinglePart::builder()
+//!                             .header(header::ContentType("text/plain; charset=utf8".parse()?))
+//!                             .body(String::from("Hello, world! :)")),
 //!                     )
-//!                 ]
-//!             })
-//!             .body("int main() { return 0; }")
-//!         )
-//!     ).unwrap();
+//!                     .multipart(
+//!                         MultiPart::related()
+//!                             .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),
+//!                             ),
+//!                     ),
+//!             )
+//!             .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!\") }")),
+//!             ),
+//!     )?;
+//! # Ok(())
+//! # }
 //! ```
 //!
+//! Which produces:
+//! <details>
+//! <summary>Click to expand</summary>
+//!
 //! ```sh
 //! 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/mixed; boundary="RTxPCn9p31oAAAAAeQxtr1FbXr/i5vW1hFlH9oJqZRMWxRMK1QLjQ4OPqFk9R+0xUb/m"
+//! Date: Sat, 12 Dec 2020 16:30:45 GMT
+//! Content-Type: multipart/mixed; boundary="0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1"
 //!
-//! --RTxPCn9p31oAAAAAeQxtr1FbXr/i5vW1hFlH9oJqZRMWxRMK1QLjQ4OPqFk9R+0xUb/m
-//! Content-Type: multipart/alternative; boundary="qW9QCn9p31oAAAAAodFBg1L1Qrraa5hEl0bDJ6kfJMUcRT2LLSWEoeyhSEbUBIqbjWqy"
+//! --0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1
+//! Content-Type: multipart/alternative; boundary="EyXdAZIgZuyUjAounq4Aj44a6MpJfqCKhm6pE1zk"
 //!
-//! --qW9QCn9p31oAAAAAodFBg1L1Qrraa5hEl0bDJ6kfJMUcRT2LLSWEoeyhSEbUBIqbjWqy
-//! Content-Transfer-Encoding: quoted-printable
+//! --EyXdAZIgZuyUjAounq4Aj44a6MpJfqCKhm6pE1zk
 //! Content-Type: text/plain; charset=utf8
+//! Content-Transfer-Encoding: 7bit
 //!
-//! =D0=9F=D1=80=D0=B8=D0=B2=D0=B5=D1=82, =D0=BC=D0=B8=D1=80!
-//! --qW9QCn9p31oAAAAAodFBg1L1Qrraa5hEl0bDJ6kfJMUcRT2LLSWEoeyhSEbUBIqbjWqy
-//! Content-Type: multipart/related; boundary="BV5RCn9p31oAAAAAUt42E9bYMDEAGCOWlxEz89Bv0qFA5Xsy6rOC3zRahMQ39IFZNnp8"
+//! Hello, world! :)
+//! --EyXdAZIgZuyUjAounq4Aj44a6MpJfqCKhm6pE1zk
+//! Content-Type: multipart/related; boundary="eM5Z18WZVOQsqi5GQ71XGAXk6NNvHUA1Xv1FWrXr"
 //!
-//! --BV5RCn9p31oAAAAAUt42E9bYMDEAGCOWlxEz89Bv0qFA5Xsy6rOC3zRahMQ39IFZNnp8
-//! Content-Transfer-Encoding: 8bit
+//! --eM5Z18WZVOQsqi5GQ71XGAXk6NNvHUA1Xv1FWrXr
 //! Content-Type: text/html; charset=utf8
+//! Content-Transfer-Encoding: 7bit
 //!
-//! <p><b>Hello</b>, <i>world</i>! <img src=smile.png></p>
-//! --BV5RCn9p31oAAAAAUt42E9bYMDEAGCOWlxEz89Bv0qFA5Xsy6rOC3zRahMQ39IFZNnp8
-//! Content-Transfer-Encoding: base64
+//! <p><b>Hello</b>, <i>world</i>! <img src=cid:123></p>
+//! --eM5Z18WZVOQsqi5GQ71XGAXk6NNvHUA1Xv1FWrXr
 //! Content-Type: image/png
 //! Content-Disposition: inline
+//! Content-ID: <123>
+//! Content-Transfer-Encoding: base64
 //!
 //! PHNtaWxlLXJhdy1pbWFnZS1kYXRhPg==
-//! --BV5RCn9p31oAAAAAUt42E9bYMDEAGCOWlxEz89Bv0qFA5Xsy6rOC3zRahMQ39IFZNnp8--
-//! --qW9QCn9p31oAAAAAodFBg1L1Qrraa5hEl0bDJ6kfJMUcRT2LLSWEoeyhSEbUBIqbjWqy--
-//! --RTxPCn9p31oAAAAAeQxtr1FbXr/i5vW1hFlH9oJqZRMWxRMK1QLjQ4OPqFk9R+0xUb/m
-//! Content-Transfer-Encoding: 7bit
+//! --eM5Z18WZVOQsqi5GQ71XGAXk6NNvHUA1Xv1FWrXr--
+//! --EyXdAZIgZuyUjAounq4Aj44a6MpJfqCKhm6pE1zk--
+//! --0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1
 //! Content-Type: text/plain; charset=utf8
-//! Content-Disposition: attachment; filename="example.c"
-//!
-//! int main() { return 0; }
-//! --RTxPCn9p31oAAAAAeQxtr1FbXr/i5vW1hFlH9oJqZRMWxRMK1QLjQ4OPqFk9R+0xUb/m--
+//! Content-Disposition: attachment; filename="example.rs"
+//! Content-Transfer-Encoding: 7bit
 //!
+//! fn main() { println!("Hello, World!") }
+//! --0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1--
 //! ```
+//! </details>
 
-pub use encoder::*;
+pub use body::{Body, IntoBody, MaybeString};
 pub use mailbox::*;
 pub use mimebody::*;
 
 pub use mime;
 
-mod encoder;
+mod body;
 pub mod header;
 mod mailbox;
 mod mimebody;
 mod utf8_b;
 
-use crate::{
-    message::header::{EmailDate, Header, Headers, MailboxesHeader},
-    Envelope, Error as EmailError,
-};
 use std::{convert::TryFrom, time::SystemTime};
+
 use uuid::Uuid;
 
+use crate::{
+    address::Envelope,
+    message::header::{ContentTransferEncoding, EmailDate, Header, Headers, MailboxesHeader},
+    Error as EmailError,
+};
+
 const DEFAULT_MESSAGE_ID_DOMAIN: &str = "localhost";
 
-pub trait EmailFormat {
+/// Something that can be formatted as an email message
+trait EmailFormat {
     // Use a writer?
     fn format(&self, out: &mut Vec<u8>);
 }
@@ -264,7 +332,7 @@ impl MessageBuilder {
 
     /// Set `Sender` header. Should be used when providing several `From` mailboxes.
     ///
-    /// https://tools.ietf.org/html/rfc5322#section-3.6.2
+    /// Defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.2).
     ///
     /// Shortcut for `self.header(header::Sender(mbox))`.
     pub fn sender(self, mbox: Mailbox) -> Self {
@@ -273,7 +341,7 @@ impl MessageBuilder {
 
     /// Set or add mailbox to `From` header
     ///
-    /// https://tools.ietf.org/html/rfc5322#section-3.6.2
+    /// Defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.2).
     ///
     /// Shortcut for `self.mailbox(header::From(mbox))`.
     pub fn from(self, mbox: Mailbox) -> Self {
@@ -282,7 +350,7 @@ impl MessageBuilder {
 
     /// Set or add mailbox to `ReplyTo` header
     ///
-    /// https://tools.ietf.org/html/rfc5322#section-3.6.2
+    /// Defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.2).
     ///
     /// Shortcut for `self.mailbox(header::ReplyTo(mbox))`.
     pub fn reply_to(self, mbox: Mailbox) -> Self {
@@ -364,7 +432,7 @@ impl MessageBuilder {
     // TODO: High-level methods for attachments and embedded files
 
     /// Create message from body
-    fn build(self, body: Body) -> Result<Message, EmailError> {
+    fn build(self, body: MessageBody) -> Result<Message, EmailError> {
         // Check for missing required headers
         // https://tools.ietf.org/html/rfc5322#section-3.6
 
@@ -399,32 +467,27 @@ impl MessageBuilder {
         })
     }
 
-    // In theory having a body is optional
-
-    /// Plain ASCII body
+    /// Create [`Message`] using a [`Vec<u8>`], [`String`], or [`Body`] body
     ///
-    /// *WARNING*: Generally not what you want
-    pub fn body<T: Into<String>>(self, body: T) -> Result<Message, EmailError> {
-        // 998 chars by line
-        // CR and LF MUST only occur together as CRLF; they MUST NOT appear
-        //  independently in the body.
-        let body = body.into();
+    /// Automatically gets encoded with `7bit`, `quoted-printable` or `base64`
+    /// `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 body = body.into_body(maybe_encoding);
 
-        if !&body.is_ascii() {
-            return Err(EmailError::NonAsciiChars);
-        }
-
-        self.build(Body::Raw(body))
+        self.headers.set(body.encoding());
+        self.build(MessageBody::Raw(body.into_vec()))
     }
 
     /// Create message using mime body ([`MultiPart`][self::MultiPart])
     pub fn multipart(self, part: MultiPart) -> Result<Message, EmailError> {
-        self.mime_1_0().build(Body::Mime(Part::Multi(part)))
+        self.mime_1_0().build(MessageBody::Mime(Part::Multi(part)))
     }
 
     /// Create message using mime body ([`SinglePart`][self::SinglePart])
     pub fn singlepart(self, part: SinglePart) -> Result<Message, EmailError> {
-        self.mime_1_0().build(Body::Mime(Part::Single(part)))
+        self.mime_1_0().build(MessageBody::Mime(Part::Single(part)))
     }
 }
 
@@ -432,14 +495,14 @@ impl MessageBuilder {
 #[derive(Clone, Debug)]
 pub struct Message {
     headers: Headers,
-    body: Body,
+    body: MessageBody,
     envelope: Envelope,
 }
 
 #[derive(Clone, Debug)]
-enum Body {
+enum MessageBody {
     Mime(Part),
-    Raw(String),
+    Raw(Vec<u8>),
 }
 
 impl Message {
@@ -469,11 +532,12 @@ impl Message {
 impl EmailFormat for Message {
     fn format(&self, out: &mut Vec<u8>) {
         out.extend_from_slice(self.headers.to_string().as_bytes());
+
         match &self.body {
-            Body::Mime(p) => p.format(out),
-            Body::Raw(r) => {
+            MessageBody::Mime(p) => p.format(out),
+            MessageBody::Raw(r) => {
                 out.extend_from_slice(b"\r\n");
-                out.extend(r.as_bytes())
+                out.extend_from_slice(&r)
             }
         }
     }
@@ -487,11 +551,13 @@ impl Default for MessageBuilder {
 
 #[cfg(test)]
 mod test {
-    use crate::message::{header, mailbox::Mailbox, Message};
+    use crate::message::{header, mailbox::Mailbox, Message, MultiPart, SinglePart};
 
     #[test]
     fn email_missing_originator() {
-        assert!(Message::builder().body("Happy new year!").is_err());
+        assert!(Message::builder()
+            .body(String::from("Happy new year!"))
+            .is_err());
     }
 
     #[test]
@@ -499,7 +565,7 @@ mod test {
         assert!(Message::builder()
             .from("NoBody <nobody@domain.tld>".parse().unwrap())
             .to("NoBody <nobody@domain.tld>".parse().unwrap())
-            .body("Happy new year!")
+            .body(String::from("Happy new year!"))
             .is_ok());
     }
 
@@ -508,7 +574,7 @@ mod test {
         assert!(Message::builder()
             .from("NoBody <nobody@domain.tld>".parse().unwrap())
             .from("AnyBody <anybody@domain.tld>".parse().unwrap())
-            .body("Happy new year!")
+            .body(String::from("Happy new year!"))
             .is_err());
     }
 
@@ -529,7 +595,7 @@ mod test {
                 vec!["Pony O.P. <pony@domain.tld>".parse().unwrap()].into(),
             ))
             .header(header::Subject("яңа ел белән!".into()))
-            .body("Happy new year!")
+            .body(String::from("Happy new year!"))
             .unwrap();
 
         assert_eq!(
@@ -539,9 +605,57 @@ mod test {
                 "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",
+                "Content-Transfer-Encoding: 7bit\r\n",
                 "\r\n",
                 "Happy new year!"
             )
         );
     }
+
+    #[test]
+    fn email_with_png() {
+        let date = "Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap();
+        let img = std::fs::read("./docs/lettre.png").unwrap();
+        let m = Message::builder()
+            .date(date)
+            .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")
+            .multipart(
+                MultiPart::related()
+                    .singlepart(
+                        SinglePart::builder()
+                            .header(header::ContentType(
+                                "text/html; charset=utf8".parse().unwrap(),
+                            ))
+                            .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()))
+                            .body(img),
+                    ),
+            )
+            .unwrap();
+
+        let output = String::from_utf8(m.formatted()).unwrap();
+        let file_expected = std::fs::read("./testdata/email_with_png.eml").unwrap();
+        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 {
+                continue;
+            }
+
+            assert_eq!(line.0, line.1)
+        }
+    }
 }

src/message/utf8_b.rs

@@ -16,19 +16,16 @@ pub fn encode(s: &str) -> String {
 }
 
 pub fn decode(s: &str) -> Option<String> {
-    const PREFIX: &str = "=?utf-8?b?";
-    const SUFFIX: &str = "?=";
-
-    let s = s.trim();
-    if s.starts_with(PREFIX) && s.ends_with(SUFFIX) {
-        let s = &s[PREFIX.len()..];
-        let s = &s[..s.len() - SUFFIX.len()];
-        base64::decode(s)
-            .ok()
-            .and_then(|v| String::from_utf8(v).ok())
-    } else {
-        Some(s.into())
-    }
+    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)]

src/transport/file/error.rs

@@ -14,16 +14,18 @@ pub enum Error {
     Client(&'static str),
     /// IO error
     Io(io::Error),
-    /// JSON serialization error
-    JsonSerialization(serde_json::Error),
+    /// JSON error
+    #[cfg(feature = "file-transport-envelope")]
+    Json(serde_json::Error),
 }
 
 impl Display for Error {
-    fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), fmt::Error> {
         match *self {
             Client(err) => fmt.write_str(err),
             Io(ref err) => err.fmt(fmt),
-            JsonSerialization(ref err) => err.fmt(fmt),
+            #[cfg(feature = "file-transport-envelope")]
+            Json(ref err) => err.fmt(fmt),
         }
     }
 }
@@ -32,7 +34,8 @@ impl StdError for Error {
     fn source(&self) -> Option<&(dyn StdError + 'static)> {
         match *self {
             Io(ref err) => Some(&*err),
-            JsonSerialization(ref err) => Some(&*err),
+            #[cfg(feature = "file-transport-envelope")]
+            Json(ref err) => Some(&*err),
             _ => None,
         }
     }
@@ -44,9 +47,10 @@ impl From<io::Error> for Error {
     }
 }
 
+#[cfg(feature = "file-transport-envelope")]
 impl From<serde_json::Error> for Error {
     fn from(err: serde_json::Error) -> Error {
-        Error::JsonSerialization(err)
+        Error::Json(err)
     }
 }
 

src/transport/file/mod.rs

@@ -1,98 +1,145 @@
 //! The file transport writes the emails to the given directory. The name of the file will be
-//! `message_id.json`.
+//! `message_id.eml`.
 //! It can be useful for testing purposes, or if you want to keep track of sent messages.
 //!
 //! ## Sync example
 //!
 //! ```rust
+//! # use std::error::Error;
+//!
+//! # #[cfg(all(feature = "file-transport", feature = "builder"))]
+//! # fn main() -> Result<(), Box<dyn Error>> {
+//! use lettre::{FileTransport, Message, Transport};
 //! use std::env::temp_dir;
-//! use lettre::{Transport, Envelope, Message, FileTransport};
 //!
 //! // Write to the local temp directory
 //! let sender = FileTransport::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())
+//!     .from("NoBody <nobody@domain.tld>".parse()?)
+//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
+//!     .to("Hei <hei@domain.tld>".parse()?)
 //!     .subject("Happy new year")
-//!     .body("Be happy!")
-//!     .unwrap();
+//!     .body(String::from("Be happy!"))?;
 //!
 //! let result = sender.send(&email);
 //! assert!(result.is_ok());
+//! # Ok(())
+//! # }
+//!
+//! # #[cfg(not(all(feature = "file-transport", feature = "builder")))]
+//! # fn main() {}
 //! ```
 //!
-//! ## Async tokio 0.2
+//! ## Sync example with envelope
+//!
+//! It is possible to also write the envelope content in a separate JSON file
+//! by using the `with_envelope` builder. The JSON file will be written in the
+//! target directory with same name and a `json` extension.
 //!
 //! ```rust
-//! # #[cfg(feature = "tokio02")]
-//! # async fn run() {
+//! # use std::error::Error;
+//!
+//! # #[cfg(all(feature = "file-transport-envelope", feature = "builder"))]
+//! # fn main() -> Result<(), Box<dyn Error>> {
+//! use lettre::{FileTransport, Message, Transport};
 //! use std::env::temp_dir;
-//! use lettre::{Tokio02Transport, Envelope, Message, FileTransport};
 //!
 //! // Write to the local temp directory
-//! let sender = FileTransport::new(temp_dir());
+//! let sender = FileTransport::with_envelope(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())
+//!     .from("NoBody <nobody@domain.tld>".parse()?)
+//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
+//!     .to("Hei <hei@domain.tld>".parse()?)
 //!     .subject("Happy new year")
-//!     .body("Be happy!")
-//!     .unwrap();
+//!     .body(String::from("Be happy!"))?;
+//!
+//! let result = sender.send(&email);
+//! assert!(result.is_ok());
+//! # Ok(())
+//! # }
+//!
+//! # #[cfg(not(all(feature = "file-transport-envelope", feature = "builder")))]
+//! # fn main() {}
+//! ```
+//!
+//! ## Async tokio 1.x
+//!
+//! ```rust,no_run
+//! # use std::error::Error;
+//!
+//! # #[cfg(all(feature = "tokio1", feature = "file-transport", feature = "builder"))]
+//! # async fn run() -> Result<(), Box<dyn Error>> {
+//! use std::env::temp_dir;
+//! use lettre::{AsyncTransport, Tokio1Executor, Message, AsyncFileTransport};
+//!
+//! // Write to the local temp directory
+//! let sender = AsyncFileTransport::<Tokio1Executor>::new(temp_dir());
+//! 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 result = sender.send(email).await;
 //! assert!(result.is_ok());
+//! # Ok(())
 //! # }
 //! ```
 //!
 //! ## Async async-std 1.x
 //!
-//! ```rust
-//! # #[cfg(feature = "async-std1")]
-//! # async fn run() {
+//! ```rust,no_run
+//! # use std::error::Error;
+//!
+//! # #[cfg(all(feature = "async-std1", feature = "file-transport", feature = "builder"))]
+//! # async fn run() -> Result<(), Box<dyn Error>> {
 //! use std::env::temp_dir;
-//! use lettre::{AsyncStd1Transport, Envelope, Message, FileTransport};
+//! use lettre::{AsyncTransport, AsyncStd1Executor, Message, AsyncFileTransport};
 //!
 //! // Write to the local temp directory
-//! let sender = FileTransport::new(temp_dir());
+//! let sender = AsyncFileTransport::<AsyncStd1Executor>::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())
+//!     .from("NoBody <nobody@domain.tld>".parse()?)
+//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
+//!     .to("Hei <hei@domain.tld>".parse()?)
 //!     .subject("Happy new year")
-//!     .body("Be happy!")
-//!     .unwrap();
+//!     .body(String::from("Be happy!"))?;
 //!
 //! let result = sender.send(email).await;
 //! assert!(result.is_ok());
+//! # Ok(())
 //! # }
 //! ```
 //!
 //! ---
 //!
-//! Example result
+//! Example email content result
+//!
+//! ```eml
+//! From: NoBody <nobody@domain.tld>
+//! Reply-To: Yuin <yuin@domain.tld>
+//! To: Hei <hei@domain.tld>
+//! Subject: Happy new year
+//! Date: Tue, 18 Aug 2020 22:50:17 GMT
+//!
+//! Be happy!
+//! ```
+//!
+//! Example envelope result
 //!
 //! ```json
-//! {
-//!   "envelope": {
-//!     "forward_path": [
-//!       "hei@domain.tld"
-//!     ],
-//!     "reverse_path": "nobody@domain.tld"
-//!   },
-//!   "raw_message": null,
-//!   "message": "From: NoBody <nobody@domain.tld>\r\nReply-To: Yuin <yuin@domain.tld>\r\nTo: Hei <hei@domain.tld>\r\nSubject: Happy new year\r\nDate: Tue, 18 Aug 2020 22:50:17 GMT\r\n\r\nBe happy!"
-//! }
+//! {"forward_path":["hei@domain.tld"],"reverse_path":"nobody@domain.tld"}
 //! ```
 
 pub use self::error::Error;
-#[cfg(feature = "async-std1")]
-use crate::AsyncStd1Transport;
-#[cfg(feature = "tokio02")]
-use crate::Tokio02Transport;
-use crate::{Envelope, Transport};
-#[cfg(any(feature = "async-std1", feature = "tokio02"))]
+use crate::{address::Envelope, Transport};
+#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+use crate::{AsyncTransport, Executor};
+#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
 use async_trait::async_trait;
+#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+use std::marker::PhantomData;
 use std::{
     path::{Path, PathBuf},
     str,
@@ -108,49 +155,105 @@ type Id = String;
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct FileTransport {
     path: PathBuf,
+    #[cfg(feature = "file-transport-envelope")]
+    save_envelope: bool,
+}
+
+#[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+pub struct AsyncFileTransport<E: Executor> {
+    inner: FileTransport,
+    marker_: PhantomData<E>,
 }
 
 impl FileTransport {
     /// Creates a new transport to the given directory
+    ///
+    /// Writes the email content in eml format.
     pub fn new<P: AsRef<Path>>(path: P) -> FileTransport {
         FileTransport {
             path: PathBuf::from(path.as_ref()),
+            #[cfg(feature = "file-transport-envelope")]
+            save_envelope: false,
         }
     }
+
+    /// Creates a new transport to the given directory
+    ///
+    /// Writes the email content in eml format and the envelope
+    /// in json format.
+    #[cfg(feature = "file-transport-envelope")]
+    pub fn with_envelope<P: AsRef<Path>>(path: P) -> FileTransport {
+        FileTransport {
+            path: PathBuf::from(path.as_ref()),
+            #[cfg(feature = "file-transport-envelope")]
+            save_envelope: true,
+        }
+    }
+
+    /// Read a message that was written using the file transport.
+    ///
+    /// Reads the envelope and the raw message content.
+    #[cfg(feature = "file-transport-envelope")]
+    pub fn read(&self, email_id: &str) -> Result<(Envelope, Vec<u8>), Error> {
+        use std::fs;
+
+        let eml_file = self.path.join(format!("{}.eml", email_id));
+        let eml = fs::read(eml_file)?;
+
+        let json_file = self.path.join(format!("{}.json", email_id));
+        let json = fs::read(&json_file)?;
+        let envelope = serde_json::from_slice(&json)?;
+
+        Ok((envelope, eml))
+    }
+
+    fn path(&self, email_id: &Uuid, extension: &str) -> PathBuf {
+        self.path.join(format!("{}.{}", email_id, extension))
+    }
 }
 
-#[derive(PartialEq, Eq, Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-struct SerializableEmail<'a> {
-    envelope: Envelope,
-    raw_message: Option<&'a [u8]>,
-    message: Option<&'a str>,
-}
+#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+impl<E> AsyncFileTransport<E>
+where
+    E: Executor,
+{
+    /// Creates a new transport to the given directory
+    ///
+    /// Writes the email content in eml format.
+    pub fn new<P: AsRef<Path>>(path: P) -> Self {
+        Self {
+            inner: FileTransport::new(path),
+            marker_: PhantomData,
+        }
+    }
 
-impl FileTransport {
-    fn send_raw_impl(
-        &self,
-        envelope: &Envelope,
-        email: &[u8],
-    ) -> Result<(Uuid, PathBuf, String), serde_json::Error> {
-        let email_id = Uuid::new_v4();
-        let file = self.path.join(format!("{}.json", email_id));
+    /// Creates a new transport to the given directory
+    ///
+    /// Writes the email content in eml format and the envelope
+    /// in json format.
+    #[cfg(feature = "file-transport-envelope")]
+    pub fn with_envelope<P: AsRef<Path>>(path: P) -> Self {
+        Self {
+            inner: FileTransport::with_envelope(path),
+            marker_: PhantomData,
+        }
+    }
 
-        let serialized = match str::from_utf8(email) {
-            // Serialize as UTF-8 string if possible
-            Ok(m) => serde_json::to_string(&SerializableEmail {
-                envelope: envelope.clone(),
-                message: Some(m),
-                raw_message: None,
-            }),
-            Err(_) => serde_json::to_string(&SerializableEmail {
-                envelope: envelope.clone(),
-                message: None,
-                raw_message: Some(email),
-            }),
-        }?;
+    /// Read a message that was written using the file transport.
+    ///
+    /// Reads the envelope and the raw message content.
+    #[cfg(feature = "file-transport-envelope")]
+    pub async fn read(&self, email_id: &str) -> Result<(Envelope, Vec<u8>), Error> {
+        let eml_file = self.inner.path.join(format!("{}.eml", email_id));
+        let eml = E::fs_read(&eml_file).await?;
 
-        Ok((email_id, file, serialized))
+        let json_file = self.inner.path.join(format!("{}.json", email_id));
+        let json = E::fs_read(&json_file).await?;
+        let envelope = serde_json::from_slice(&json)?;
+
+        Ok((envelope, eml))
     }
 }
 
@@ -161,41 +264,51 @@ impl Transport for FileTransport {
     fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
         use std::fs;
 
-        let (email_id, file, serialized) = self.send_raw_impl(envelope, email)?;
+        let email_id = Uuid::new_v4();
+
+        let file = self.path(&email_id, "eml");
+        fs::write(file, email)?;
+
+        #[cfg(feature = "file-transport-envelope")]
+        {
+            if self.save_envelope {
+                let file = self.path(&email_id, "json");
+                fs::write(file, serde_json::to_string(&envelope)?)?;
+            }
+        }
+        // use envelope anyway
+        let _ = envelope;
 
-        fs::write(file, serialized)?;
         Ok(email_id.to_string())
     }
 }
 
-#[cfg(feature = "async-std1")]
+#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
 #[async_trait]
-impl AsyncStd1Transport for FileTransport {
+impl<E> AsyncTransport for AsyncFileTransport<E>
+where
+    E: Executor,
+{
     type Ok = Id;
     type Error = Error;
 
     async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
-        use async_std::fs;
+        let email_id = Uuid::new_v4();
 
-        let (email_id, file, serialized) = self.send_raw_impl(envelope, email)?;
+        let file = self.inner.path(&email_id, "eml");
+        E::fs_write(&file, email).await?;
+
+        #[cfg(feature = "file-transport-envelope")]
+        {
+            if self.inner.save_envelope {
+                let file = self.inner.path(&email_id, "json");
+                let buf = serde_json::to_vec(&envelope)?;
+                E::fs_write(&file, &buf).await?;
+            }
+        }
+        // use envelope anyway
+        let _ = envelope;
 
-        fs::write(file, serialized).await?;
-        Ok(email_id.to_string())
-    }
-}
-
-#[cfg(feature = "tokio02")]
-#[async_trait]
-impl Tokio02Transport for FileTransport {
-    type Ok = Id;
-    type Error = Error;
-
-    async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
-        use tokio02_crate::fs;
-
-        let (email_id, file, serialized) = self.send_raw_impl(envelope, email)?;
-
-        fs::write(file, serialized).await?;
         Ok(email_id.to_string())
     }
 }

src/transport/mod.rs

@@ -16,10 +16,77 @@
 //! * The `StubTransport` is useful for debugging, and only prints the content of the email in the
 //!   logs.
 
+#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+use async_trait::async_trait;
+
+#[doc(hidden)]
+#[deprecated(note = "use lettre::AsyncStd1Transport")]
+#[cfg(feature = "async-std1")]
+pub use self::AsyncTransport as AsyncStd1Transport;
+#[doc(hidden)]
+#[deprecated(note = "use lettre::Tokio1Transport")]
+#[cfg(feature = "tokio1")]
+pub use self::AsyncTransport as Tokio1Transport;
+#[doc(hidden)]
+#[deprecated(note = "use lettre::Tokio02Transport")]
+#[cfg(feature = "tokio02")]
+pub use self::AsyncTransport as Tokio02Transport;
+
+use crate::Envelope;
+#[cfg(feature = "builder")]
+use crate::Message;
+
 #[cfg(feature = "file-transport")]
+#[cfg_attr(docsrs, doc(cfg(feature = "file-transport")))]
 pub mod file;
 #[cfg(feature = "sendmail-transport")]
+#[cfg_attr(docsrs, doc(cfg(feature = "sendmail-transport")))]
 pub mod sendmail;
 #[cfg(feature = "smtp-transport")]
+#[cfg_attr(docsrs, doc(cfg(feature = "smtp-transport")))]
 pub mod smtp;
 pub mod stub;
+
+/// Blocking Transport method for emails
+pub trait Transport {
+    /// Response produced by the Transport
+    type Ok;
+    /// Error produced by the Transport
+    type Error;
+
+    /// Sends the email
+    #[cfg(feature = "builder")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "builder")))]
+    fn send(&self, message: &Message) -> Result<Self::Ok, Self::Error> {
+        let raw = message.formatted();
+        self.send_raw(message.envelope(), &raw)
+    }
+
+    fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error>;
+}
+
+/// 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")))
+)]
+#[async_trait]
+pub trait AsyncTransport {
+    /// Response produced by the Transport
+    type Ok;
+    /// Error produced by the Transport
+    type Error;
+
+    /// Sends the email
+    #[cfg(feature = "builder")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "builder")))]
+    // TODO take &Message
+    async fn send(&self, message: Message) -> Result<Self::Ok, Self::Error> {
+        let raw = message.formatted();
+        let envelope = message.envelope();
+        self.send_raw(&envelope, &raw).await
+    }
+
+    async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error>;
+}

src/transport/sendmail/error.rs

@@ -20,7 +20,7 @@ pub enum Error {
 }
 
 impl Display for Error {
-    fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), fmt::Error> {
         match *self {
             Client(ref err) => err.fmt(fmt),
             Utf8Parsing(ref err) => err.fmt(fmt),

src/transport/sendmail/mod.rs

@@ -3,73 +3,113 @@
 //! ## Sync example
 //!
 //! ```rust
-//! use lettre::{Message, Envelope, Transport, SendmailTransport};
+//! # use std::error::Error;
+//!
+//! # #[cfg(all(feature = "sendmail-transport", feature = "builder"))]
+//! # fn main() -> Result<(), Box<dyn Error>> {
+//! # use lettre::{Message, Transport, SendmailTransport};
 //!
 //! 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())
+//!     .from("NoBody <nobody@domain.tld>".parse()?)
+//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
+//!     .to("Hei <hei@domain.tld>".parse()?)
 //!     .subject("Happy new year")
-//!     .body("Be happy!")
-//!     .unwrap();
+//!     .body(String::from("Be happy!"))?;
 //!
 //! let sender = SendmailTransport::new();
 //! let result = sender.send(&email);
 //! assert!(result.is_ok());
+//! # Ok(())
+//! # }
+//!
+//! # #[cfg(not(all(feature = "sendmail-transport", feature = "builder")))]
+//! # fn main() {}
 //! ```
 //!
 //! ## Async tokio 0.2 example
 //!
-//! ```rust
-//! # #[cfg(feature = "tokio02")]
-//! # async fn run() {
-//! use lettre::{Message, Envelope, Tokio02Transport, SendmailTransport};
+//! ```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().unwrap())
-//!     .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-//!     .to("Hei <hei@domain.tld>".parse().unwrap())
+//!     .from("NoBody <nobody@domain.tld>".parse()?)
+//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
+//!     .to("Hei <hei@domain.tld>".parse()?)
 //!     .subject("Happy new year")
-//!     .body("Be happy!")
-//!     .unwrap();
+//!     .body(String::from("Be happy!"))?;
 //!
-//! let sender = SendmailTransport::new();
+//! let sender = AsyncSendmailTransport::<Tokio02Executor>::new();
 //! let result = sender.send(email).await;
 //! assert!(result.is_ok());
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! ## Async tokio 1.x example
+//!
+//! ```rust,no_run
+//! # use std::error::Error;
+//!
+//! # #[cfg(all(feature = "tokio1", feature = "sendmail-transport", feature = "builder"))]
+//! # async fn run() -> Result<(), Box<dyn Error>> {
+//! use lettre::{Message, AsyncTransport, Tokio1Executor, 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::<Tokio1Executor>::new();
+//! let result = sender.send(email).await;
+//! assert!(result.is_ok());
+//! # Ok(())
 //! # }
 //! ```
 //!
 //! ## Async async-std 1.x example
 //!
-//!```rust
-//! # #[cfg(feature = "async-std1")]
-//! # async fn run() {
-//! use lettre::{Message, Envelope, AsyncStd1Transport, SendmailTransport};
+//!```rust,no_run
+//! # use std::error::Error;
+//!
+//! # #[cfg(all(feature = "async-std1", feature = "sendmail-transport", feature = "builder"))]
+//! # async fn run() -> Result<(), Box<dyn Error>> {
+//! use lettre::{Message, AsyncTransport, AsyncStd1Executor, AsyncSendmailTransport};
 //!
 //! 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())
+//!     .from("NoBody <nobody@domain.tld>".parse()?)
+//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
+//!     .to("Hei <hei@domain.tld>".parse()?)
 //!     .subject("Happy new year")
-//!     .body("Be happy!")
-//!     .unwrap();
+//!     .body(String::from("Be happy!"))?;
 //!
-//! let sender = SendmailTransport::new();
+//! let sender = AsyncSendmailTransport::<AsyncStd1Executor>::new();
 //! let result = sender.send(email).await;
 //! assert!(result.is_ok());
+//! # Ok(())
 //! # }
 //! ```
 
 pub use self::error::Error;
 #[cfg(feature = "async-std1")]
-use crate::AsyncStd1Transport;
+use crate::AsyncStd1Executor;
 #[cfg(feature = "tokio02")]
-use crate::Tokio02Transport;
-use crate::{Envelope, Transport};
-#[cfg(any(feature = "async-std1", 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"))]
+use crate::{AsyncTransport, Executor};
+#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
 use async_trait::async_trait;
+#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+use std::marker::PhantomData;
 use std::{
-    convert::AsRef,
     ffi::OsString,
     io::prelude::*,
     process::{Command, Stdio},
@@ -80,12 +120,20 @@ mod error;
 const DEFAUT_SENDMAIL: &str = "/usr/sbin/sendmail";
 
 /// Sends an email using the `sendmail` command
-#[derive(Debug, Default)]
+#[derive(Debug, Clone)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct SendmailTransport {
     command: OsString,
 }
 
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+pub struct AsyncSendmailTransport<E: Executor> {
+    inner: SendmailTransport,
+    marker_: PhantomData<E>,
+}
+
 impl SendmailTransport {
     /// Creates a new transport with the default `/usr/sbin/sendmail` command
     pub fn new() -> SendmailTransport {
@@ -103,29 +151,110 @@ impl SendmailTransport {
 
     fn command(&self, envelope: &Envelope) -> Command {
         let mut c = Command::new(&self.command);
-        c.arg("-i")
-            .arg("-f")
-            .arg(envelope.from().map(|f| f.as_ref()).unwrap_or("\"\""))
+        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());
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped());
         c
     }
+}
+
+#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+impl<E> AsyncSendmailTransport<E>
+where
+    E: Executor,
+{
+    /// Creates a new transport with the default `/usr/sbin/sendmail` command
+    pub fn new() -> Self {
+        Self {
+            inner: SendmailTransport::new(),
+            marker_: PhantomData,
+        }
+    }
+
+    /// Creates a new transport to the given sendmail command
+    pub fn new_with_command<S: Into<OsString>>(command: S) -> Self {
+        Self {
+            inner: SendmailTransport::new_with_command(command),
+            marker_: PhantomData,
+        }
+    }
 
     #[cfg(feature = "tokio02")]
     fn tokio02_command(&self, envelope: &Envelope) -> tokio02_crate::process::Command {
         use tokio02_crate::process::Command;
 
-        let mut c = Command::new(&self.command);
+        let mut c = Command::new(&self.inner.command);
         c.kill_on_drop(true);
-        c.arg("-i")
-            .arg("-f")
-            .arg(envelope.from().map(|f| f.as_ref()).unwrap_or("\"\""))
+        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());
+            .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;
+
+        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 = "async-std1")]
+    fn async_std_command(&self, envelope: &Envelope) -> async_std::process::Command {
+        use async_std::process::Command;
+
+        let mut c = Command::new(&self.inner.command);
+        // TODO: figure out why enabling this kills it earlier
+        // 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
+    }
+}
+
+impl Default for SendmailTransport {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+impl<E> Default for AsyncSendmailTransport<E>
+where
+    E: Executor,
+{
+    fn default() -> Self {
+        Self::new()
+    }
 }
 
 impl Transport for SendmailTransport {
@@ -149,23 +278,20 @@ impl Transport for SendmailTransport {
 
 #[cfg(feature = "async-std1")]
 #[async_trait]
-impl AsyncStd1Transport for SendmailTransport {
+impl AsyncTransport for AsyncSendmailTransport<AsyncStd1Executor> {
     type Ok = ();
     type Error = Error;
 
     async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
-        let mut command = self.command(envelope);
-        let email = email.to_vec();
+        use async_std::io::prelude::WriteExt;
 
-        // TODO: Convert to real async, once async-std has a process implementation.
-        let output = async_std::task::spawn_blocking(move || {
-            // Spawn the sendmail command
-            let mut process = command.spawn()?;
+        let mut command = self.async_std_command(envelope);
 
-            process.stdin.as_mut().unwrap().write_all(&email)?;
-            process.wait_with_output()
-        })
-        .await?;
+        // Spawn the sendmail command
+        let mut process = command.spawn()?;
+
+        process.stdin.as_mut().unwrap().write_all(&email).await?;
+        let output = process.output().await?;
 
         if output.status.success() {
             Ok(())
@@ -177,7 +303,7 @@ impl AsyncStd1Transport for SendmailTransport {
 
 #[cfg(feature = "tokio02")]
 #[async_trait]
-impl Tokio02Transport for SendmailTransport {
+impl AsyncTransport for AsyncSendmailTransport<Tokio02Executor> {
     type Ok = ();
     type Error = Error;
 
@@ -199,3 +325,28 @@ impl Tokio02Transport for SendmailTransport {
         }
     }
 }
+
+#[cfg(feature = "tokio1")]
+#[async_trait]
+impl AsyncTransport for AsyncSendmailTransport<Tokio1Executor> {
+    type Ok = ();
+    type Error = Error;
+
+    async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
+        use tokio1_crate::io::AsyncWriteExt;
+
+        let mut command = self.tokio1_command(envelope);
+
+        // Spawn the sendmail command
+        let mut process = command.spawn()?;
+
+        process.stdin.as_mut().unwrap().write_all(&email).await?;
+        let output = process.wait_with_output().await?;
+
+        if output.status.success() {
+            Ok(())
+        } else {
+            Err(Error::Client(String::from_utf8(output.stderr)?))
+        }
+    }
+}

src/transport/smtp/async_transport.rs

@@ -1,21 +1,29 @@
+use std::marker::PhantomData;
+
 use async_trait::async_trait;
 
-#[cfg(feature = "tokio02")]
-use super::Tls;
 use super::{
     client::AsyncSmtpConnection, ClientId, Credentials, Error, Mechanism, Response, SmtpInfo,
 };
-use crate::{Envelope, Tokio02Transport};
+#[cfg(feature = "async-std1")]
+use crate::AsyncStd1Executor;
+#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
+use crate::AsyncTransport;
+#[cfg(feature = "tokio02")]
+use crate::Tokio02Executor;
+#[cfg(feature = "tokio1")]
+use crate::Tokio1Executor;
+use crate::{Envelope, Executor};
 
 #[allow(missing_debug_implementations)]
-#[derive(Clone)]
-pub struct AsyncSmtpTransport<C> {
+pub struct AsyncSmtpTransport<E> {
     // TODO: pool
-    inner: AsyncSmtpClient<C>,
+    inner: AsyncSmtpClient<E>,
 }
 
+#[cfg(feature = "tokio02")]
 #[async_trait]
-impl Tokio02Transport for AsyncSmtpTransport<Tokio02Connector> {
+impl AsyncTransport for AsyncSmtpTransport<Tokio02Executor> {
     type Ok = Response;
     type Error = Error;
 
@@ -31,21 +39,64 @@ impl Tokio02Transport for AsyncSmtpTransport<Tokio02Connector> {
     }
 }
 
-impl<C> AsyncSmtpTransport<C>
+#[cfg(feature = "tokio1")]
+#[async_trait]
+impl AsyncTransport for AsyncSmtpTransport<Tokio1Executor> {
+    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 = "async-std1")]
+#[async_trait]
+impl AsyncTransport for AsyncSmtpTransport<AsyncStd1Executor> {
+    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)
+    }
+}
+
+impl<E> AsyncSmtpTransport<E>
 where
-    C: AsyncSmtpConnector,
+    E: Executor,
 {
-    /// Simple and secure transport, using TLS connections to comunicate with the SMTP server
+    /// Simple and secure transport, using TLS connections to communicate with the SMTP server
     ///
     /// The right option for most SMTP servers.
     ///
     /// 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"))]
+    #[cfg(any(
+        feature = "tokio02-native-tls",
+        feature = "tokio02-rustls-tls",
+        feature = "tokio1-native-tls",
+        feature = "tokio1-rustls-tls",
+        feature = "async-std1-native-tls",
+        feature = "async-std1-rustls-tls"
+    ))]
     pub fn relay(relay: &str) -> Result<AsyncSmtpTransportBuilder, Error> {
-        use super::{TlsParameters, SUBMISSIONS_PORT};
+        use super::{Tls, TlsParameters, SUBMISSIONS_PORT};
 
-        let tls_parameters = TlsParameters::new_tokio02(relay.into())?;
+        let tls_parameters = TlsParameters::new(relay.into())?;
 
         Ok(Self::builder_dangerous(relay)
             .port(SUBMISSIONS_PORT)
@@ -63,9 +114,16 @@ 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"))]
+    #[cfg(any(
+        feature = "tokio02-native-tls",
+        feature = "tokio02-rustls-tls",
+        feature = "tokio1-native-tls",
+        feature = "tokio1-rustls-tls",
+        feature = "async-std1-native-tls",
+        feature = "async-std1-rustls-tls"
+    ))]
     pub fn starttls_relay(relay: &str) -> Result<AsyncSmtpTransportBuilder, Error> {
-        use super::{TlsParameters, SUBMISSION_PORT};
+        use super::{Tls, TlsParameters, SUBMISSION_PORT};
 
         let tls_parameters = TlsParameters::new(relay.into())?;
 
@@ -77,7 +135,7 @@ where
     /// Creates a new local SMTP client to port 25
     ///
     /// Shortcut for local unencrypted relay (typical local email daemon that will handle relaying)
-    pub fn unencrypted_localhost() -> AsyncSmtpTransport<C> {
+    pub fn unencrypted_localhost() -> AsyncSmtpTransport<E> {
         Self::builder_dangerous("localhost").build()
     }
 
@@ -93,13 +151,27 @@ where
     /// [`AsyncSmtpTransport::starttls_relay`](#method.starttls_relay) instead,
     /// if possible.
     pub fn builder_dangerous<T: Into<String>>(server: T) -> AsyncSmtpTransportBuilder {
-        let mut new = SmtpInfo::default();
-        new.server = server.into();
+        let new = SmtpInfo {
+            server: server.into(),
+            ..Default::default()
+        };
         AsyncSmtpTransportBuilder { info: new }
     }
 }
 
-/// Contains client configuration
+impl<E> Clone for AsyncSmtpTransport<E>
+where
+    E: Executor,
+{
+    fn clone(&self) -> Self {
+        Self {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+/// Contains client configuration.
+/// Instances of this struct can be created using functions of [`AsyncSmtpTransport`].
 #[allow(missing_debug_implementations)]
 #[derive(Clone)]
 pub struct AsyncSmtpTransportBuilder {
@@ -133,42 +205,47 @@ impl AsyncSmtpTransportBuilder {
     }
 
     /// Set the TLS settings to use
-    #[cfg(any(feature = "tokio02-native-tls", feature = "tokio02-rustls-tls"))]
-    pub fn tls(mut self, tls: Tls) -> Self {
+    #[cfg(any(
+        feature = "tokio02-native-tls",
+        feature = "tokio02-rustls-tls",
+        feature = "tokio1-native-tls",
+        feature = "tokio1-rustls-tls",
+        feature = "async-std1-native-tls",
+        feature = "async-std1-rustls-tls"
+    ))]
+    pub fn tls(mut self, tls: super::Tls) -> Self {
         self.info.tls = tls;
         self
     }
 
     /// Build the transport (with default pool if enabled)
-    pub fn build<C>(self) -> AsyncSmtpTransport<C>
+    pub fn build<E>(self) -> AsyncSmtpTransport<E>
     where
-        C: AsyncSmtpConnector,
+        E: Executor,
     {
-        let connector = Default::default();
         let client = AsyncSmtpClient {
-            connector,
             info: self.info,
+            marker_: PhantomData,
         };
         AsyncSmtpTransport { inner: client }
     }
 }
 
 /// Build client
-#[derive(Clone)]
 pub struct AsyncSmtpClient<C> {
-    connector: C,
     info: SmtpInfo,
+    marker_: PhantomData<C>,
 }
 
-impl<C> AsyncSmtpClient<C>
+impl<E> AsyncSmtpClient<E>
 where
-    C: AsyncSmtpConnector,
+    E: Executor,
 {
     /// Creates a new connection directly usable to send emails
     ///
     /// Handles encryption and authentication
     pub async fn connection(&self) -> Result<AsyncSmtpConnection, Error> {
-        let mut conn = C::connect(
+        let mut conn = E::connect(
             &self.info.server,
             self.info.port,
             &self.info.hello_name,
@@ -183,61 +260,33 @@ where
     }
 }
 
-#[async_trait]
-pub trait AsyncSmtpConnector: Default + private::Sealed {
-    async fn connect(
-        hostname: &str,
-        port: u16,
-        hello_name: &ClientId,
-        tls: &Tls,
-    ) -> Result<AsyncSmtpConnection, Error>;
-}
-
-#[derive(Debug, Copy, Clone, Default)]
-#[cfg(feature = "tokio02")]
-pub struct Tokio02Connector;
-
-#[async_trait]
-#[cfg(feature = "tokio02")]
-impl AsyncSmtpConnector for Tokio02Connector {
-    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,
-        };
-        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?;
-            }
-            _ => (),
+impl<E> AsyncSmtpClient<E>
+where
+    E: Executor,
+{
+    fn clone(&self) -> Self {
+        Self {
+            info: self.info.clone(),
+            marker_: PhantomData,
         }
-
-        Ok(conn)
     }
 }
 
-mod private {
-    use super::*;
+#[doc(hidden)]
+#[deprecated(note = "use lettre::Executor instead")]
+pub use crate::Executor as AsyncSmtpConnector;
 
-    pub trait Sealed {}
+#[doc(hidden)]
+#[deprecated(note = "use lettre::Tokio02Executor instead")]
+#[cfg(feature = "tokio02")]
+pub type Tokio02Connector = crate::Tokio02Executor;
 
-    #[cfg(feature = "tokio02")]
-    impl Sealed for Tokio02Connector {}
-}
+#[doc(hidden)]
+#[deprecated(note = "use lettre::Tokio1Executor instead")]
+#[cfg(feature = "tokio1")]
+pub type Tokio1Connector = crate::Tokio1Executor;
+
+#[doc(hidden)]
+#[deprecated(note = "use lettre::AsyncStd1Executor instead")]
+#[cfg(feature = "async-std1")]
+pub type AsyncStd1Connector = crate::AsyncStd1Executor;

src/transport/smtp/authentication.rs

@@ -7,25 +7,6 @@ use std::fmt::{self, Display, Formatter};
 /// Trying LOGIN last as it is deprecated.
 pub const DEFAULT_MECHANISMS: &[Mechanism] = &[Mechanism::Plain, Mechanism::Login];
 
-/// Convertible to user credentials
-pub trait IntoCredentials {
-    /// Converts to a `Credentials` struct
-    fn into_credentials(self) -> Credentials;
-}
-
-impl IntoCredentials for Credentials {
-    fn into_credentials(self) -> Credentials {
-        self
-    }
-}
-
-impl<S: Into<String>, T: Into<String>> IntoCredentials for (S, T) {
-    fn into_credentials(self) -> Credentials {
-        let (username, password) = self;
-        Credentials::new(username.into(), password.into())
-    }
-}
-
 /// Contains user credentials
 #[derive(PartialEq, Eq, Clone, Hash, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -44,24 +25,35 @@ impl Credentials {
     }
 }
 
+impl<S, T> From<(S, T)> for Credentials
+where
+    S: Into<String>,
+    T: Into<String>,
+{
+    fn from((username, password): (S, T)) -> Self {
+        Credentials::new(username.into(), password.into())
+    }
+}
+
 /// Represents authentication mechanisms
 #[derive(PartialEq, Eq, Copy, Clone, Hash, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum Mechanism {
-    /// PLAIN authentication mechanism
-    /// RFC 4616: https://tools.ietf.org/html/rfc4616
+    /// PLAIN authentication mechanism, defined in
+    /// [RFC 4616](https://tools.ietf.org/html/rfc4616)
     Plain,
     /// LOGIN authentication mechanism
     /// Obsolete but needed for some providers (like office365)
-    /// https://www.ietf.org/archive/id/draft-murchison-sasl-login-00.txt
+    ///
+    /// Defined in [draft-murchison-sasl-login-00](https://www.ietf.org/archive/id/draft-murchison-sasl-login-00.txt).
     Login,
-    /// Non-standard XOAUTH2 mechanism
-    /// https://developers.google.com/gmail/imap/xoauth2-protocol
+    /// Non-standard XOAUTH2 mechanism, defined in
+    /// [xoauth2-protocol](https://developers.google.com/gmail/imap/xoauth2-protocol)
     Xoauth2,
 }
 
 impl Display for Mechanism {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.write_str(match *self {
             Mechanism::Plain => "PLAIN",
             Mechanism::Login => "LOGIN",
@@ -168,4 +160,12 @@ mod test {
         );
         assert!(mechanism.response(&credentials, Some("test")).is_err());
     }
+
+    #[test]
+    fn test_from_user_pass_for_credentials() {
+        assert_eq!(
+            Credentials::new("alice".to_string(), "wonderland".to_string()),
+            Credentials::from(("alice", "wonderland"))
+        );
+    }
 }

src/transport/smtp/client/async_connection.rs

@@ -45,11 +45,10 @@ impl AsyncSmtpConnection {
         &self.server_info
     }
 
-    // FIXME add simple connect and rename this one
-
     /// Connects to the configured server
     ///
     /// Sends EHLO and parses server information
+    #[cfg(feature = "tokio02")]
     pub async fn connect_tokio02(
         hostname: &str,
         port: u16,
@@ -60,6 +59,34 @@ impl AsyncSmtpConnection {
         Self::connect_impl(stream, hello_name).await
     }
 
+    /// Connects to the configured server
+    ///
+    /// Sends EHLO and parses server information
+    #[cfg(feature = "tokio1")]
+    pub async fn connect_tokio1(
+        hostname: &str,
+        port: u16,
+        hello_name: &ClientId,
+        tls_parameters: Option<TlsParameters>,
+    ) -> Result<AsyncSmtpConnection, Error> {
+        let stream = AsyncNetworkStream::connect_tokio1(hostname, port, tls_parameters).await?;
+        Self::connect_impl(stream, hello_name).await
+    }
+
+    /// Connects to the configured server
+    ///
+    /// Sends EHLO and parses server information
+    #[cfg(feature = "async-std1")]
+    pub async fn connect_asyncstd1(
+        hostname: &str,
+        port: u16,
+        hello_name: &ClientId,
+        tls_parameters: Option<TlsParameters>,
+    ) -> Result<AsyncSmtpConnection, Error> {
+        let stream = AsyncNetworkStream::connect_asyncstd1(hostname, port, tls_parameters).await?;
+        Self::connect_impl(stream, hello_name).await
+    }
+
     async fn connect_impl(
         stream: AsyncNetworkStream,
         hello_name: &ClientId,
@@ -85,9 +112,32 @@ impl AsyncSmtpConnection {
         // Mail
         let mut mail_options = vec![];
 
-        if self.server_info().supports_feature(Extension::EightBitMime) {
+        // Internationalization handling
+        //
+        // * 8BITMIME: https://tools.ietf.org/html/rfc6152
+        // * SMTPUTF8: https://tools.ietf.org/html/rfc653
+
+        // Check for non-ascii addresses and use the SMTPUTF8 option if any.
+        if envelope.has_non_ascii_addresses() {
+            if !self.server_info().supports_feature(Extension::SmtpUtfEight) {
+                // don't try to send non-ascii addresses (per RFC)
+                return Err(Error::Client(
+                    "Envelope contains non-ascii chars but server does not support SMTPUTF8",
+                ));
+            }
+            mail_options.push(MailParameter::SmtpUtfEight);
+        }
+
+        // Check for non-ascii content in message
+        if !email.is_ascii() {
+            if !self.server_info().supports_feature(Extension::EightBitMime) {
+                return Err(Error::Client(
+                    "Message contains non-ascii chars but server does not support 8BITMIME",
+                ));
+            }
             mail_options.push(MailParameter::Body(MailBodyParameter::EightBitMime));
         }
+
         try_smtp!(
             self.command(Mail::new(envelope.from().cloned(), mail_options))
                 .await,
@@ -255,11 +305,11 @@ impl AsyncSmtpConnection {
                     return Err(response.into());
                 }
                 Err(nom::Err::Failure(e)) => {
-                    return Err(Error::Parsing(e.1));
+                    return Err(Error::Parsing(e.code));
                 }
                 Err(nom::Err::Incomplete(_)) => { /* read more */ }
                 Err(nom::Err::Error(e)) => {
-                    return Err(Error::Parsing(e.1));
+                    return Err(Error::Parsing(e.code));
                 }
             }
         }

src/transport/smtp/client/async_net.rs

@@ -1,24 +1,53 @@
-#[cfg(feature = "tokio02-rustls-tls")]
+#[cfg(any(
+    feature = "tokio02-rustls-tls",
+    feature = "tokio1-rustls-tls",
+    feature = "async-std1-rustls-tls"
+))]
 use std::sync::Arc;
 use std::{
-    net::{Shutdown, SocketAddr},
+    net::SocketAddr,
     pin::Pin,
     task::{Context, Poll},
 };
 
-use futures_io::{Error as IoError, ErrorKind, Result as IoResult};
+use futures_io::{
+    AsyncRead as FuturesAsyncRead, AsyncWrite as FuturesAsyncWrite, Error as IoError, ErrorKind,
+    Result as IoResult,
+};
 #[cfg(feature = "tokio02")]
-use tokio02_crate::io::{AsyncRead, AsyncWrite};
-#[cfg(feature = "tokio02")]
-use tokio02_crate::net::TcpStream;
+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;
+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 RustlsTlsStream;
+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"))]
+#[cfg(any(
+    feature = "tokio02-native-tls",
+    feature = "tokio02-rustls-tls",
+    feature = "tokio1-native-tls",
+    feature = "tokio1-rustls-tls",
+    feature = "async-std1-native-tls",
+    feature = "async-std1-rustls-tls"
+))]
 use super::InnerTlsParameters;
 use super::TlsParameters;
 use crate::transport::smtp::Error;
@@ -29,17 +58,38 @@ pub struct AsyncNetworkStream {
 }
 
 /// Represents the different types of underlying network streams
+// usually only one TLS backend at a time is going to be enabled,
+// so clippy::large_enum_variant doesn't make sense here
+#[allow(clippy::large_enum_variant)]
 #[allow(dead_code)]
 enum InnerAsyncNetworkStream {
-    /// Plain TCP stream
+    /// Plain Tokio 0.2 TCP stream
     #[cfg(feature = "tokio02")]
-    Tokio02Tcp(TcpStream),
-    /// Encrypted TCP stream
+    Tokio02Tcp(Tokio02TcpStream),
+    /// Encrypted Tokio 0.2 TCP stream
     #[cfg(feature = "tokio02-native-tls")]
-    Tokio02NativeTls(TlsStream<TcpStream>),
-    /// Encrypted TCP stream
+    Tokio02NativeTls(Tokio02TlsStream<Tokio02TcpStream>),
+    /// Encrypted Tokio 0.2 TCP stream
     #[cfg(feature = "tokio02-rustls-tls")]
-    Tokio02RustlsTls(Box<RustlsTlsStream<TcpStream>>),
+    Tokio02RustlsTls(Tokio02RustlsTlsStream<Tokio02TcpStream>),
+    /// Plain Tokio 1.x TCP stream
+    #[cfg(feature = "tokio1")]
+    Tokio1Tcp(Tokio1TcpStream),
+    /// Encrypted Tokio 1.x TCP stream
+    #[cfg(feature = "tokio1-native-tls")]
+    Tokio1NativeTls(Tokio1TlsStream<Tokio1TcpStream>),
+    /// Encrypted Tokio 1.x TCP stream
+    #[cfg(feature = "tokio1-rustls-tls")]
+    Tokio1RustlsTls(Tokio1RustlsTlsStream<Tokio1TcpStream>),
+    /// Plain Tokio 1.x TCP stream
+    #[cfg(feature = "async-std1")]
+    AsyncStd1Tcp(AsyncStd1TcpStream),
+    /// Encrypted Tokio 1.x TCP stream
+    #[cfg(feature = "async-std1-native-tls")]
+    AsyncStd1NativeTls(AsyncStd1TlsStream<AsyncStd1TcpStream>),
+    /// Encrypted Tokio 1.x TCP stream
+    #[cfg(feature = "async-std1-rustls-tls")]
+    AsyncStd1RustlsTls(AsyncStd1RustlsTlsStream<AsyncStd1TcpStream>),
     /// Can't be built
     None,
 }
@@ -47,7 +97,7 @@ enum InnerAsyncNetworkStream {
 impl AsyncNetworkStream {
     fn new(inner: InnerAsyncNetworkStream) -> Self {
         if let InnerAsyncNetworkStream::None = inner {
-            debug_assert!(false, "InnerAsyncNetworkStream::None should never be built");
+            debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
         }
 
         AsyncNetworkStream { inner }
@@ -64,41 +114,37 @@ impl AsyncNetworkStream {
             }
             #[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")]
+            InnerAsyncNetworkStream::Tokio1NativeTls(ref s) => {
+                s.get_ref().get_ref().get_ref().peer_addr()
+            }
+            #[cfg(feature = "tokio1-rustls-tls")]
+            InnerAsyncNetworkStream::Tokio1RustlsTls(ref s) => s.get_ref().0.peer_addr(),
+            #[cfg(feature = "async-std1")]
+            InnerAsyncNetworkStream::AsyncStd1Tcp(ref s) => s.peer_addr(),
+            #[cfg(feature = "async-std1-native-tls")]
+            InnerAsyncNetworkStream::AsyncStd1NativeTls(ref s) => s.get_ref().peer_addr(),
+            #[cfg(feature = "async-std1-rustls-tls")]
+            InnerAsyncNetworkStream::AsyncStd1RustlsTls(ref s) => s.get_ref().0.peer_addr(),
             InnerAsyncNetworkStream::None => {
-                debug_assert!(false, "InnerAsyncNetworkStream::None should never be built");
+                debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
                 Err(IoError::new(
                     ErrorKind::Other,
-                    "InnerAsyncNetworkStream::None should never be built",
+                    "InnerAsyncNetworkStream::None must never be built",
                 ))
             }
         }
     }
 
-    /// Shutdowns the connection
-    pub fn shutdown(&self, how: Shutdown) -> IoResult<()> {
-        match self.inner {
-            #[cfg(feature = "tokio02")]
-            InnerAsyncNetworkStream::Tokio02Tcp(ref s) => s.shutdown(how),
-            #[cfg(feature = "tokio02-native-tls")]
-            InnerAsyncNetworkStream::Tokio02NativeTls(ref s) => {
-                s.get_ref().get_ref().get_ref().shutdown(how)
-            }
-            #[cfg(feature = "tokio02-rustls-tls")]
-            InnerAsyncNetworkStream::Tokio02RustlsTls(ref s) => s.get_ref().0.shutdown(how),
-            InnerAsyncNetworkStream::None => {
-                debug_assert!(false, "InnerAsyncNetworkStream::None should never be built");
-                Ok(())
-            }
-        }
-    }
-
     #[cfg(feature = "tokio02")]
     pub async fn connect_tokio02(
         hostname: &str,
         port: u16,
         tls_parameters: Option<TlsParameters>,
     ) -> Result<AsyncNetworkStream, Error> {
-        let tcp_stream = TcpStream::connect((hostname, port)).await?;
+        let tcp_stream = Tokio02TcpStream::connect((hostname, port)).await?;
 
         let mut stream = AsyncNetworkStream::new(InnerAsyncNetworkStream::Tokio02Tcp(tcp_stream));
         if let Some(tls_parameters) = tls_parameters {
@@ -107,9 +153,42 @@ impl AsyncNetworkStream {
         Ok(stream)
     }
 
+    #[cfg(feature = "tokio1")]
+    pub async fn connect_tokio1(
+        hostname: &str,
+        port: u16,
+        tls_parameters: Option<TlsParameters>,
+    ) -> Result<AsyncNetworkStream, Error> {
+        let tcp_stream = Tokio1TcpStream::connect((hostname, port)).await?;
+
+        let mut stream = AsyncNetworkStream::new(InnerAsyncNetworkStream::Tokio1Tcp(tcp_stream));
+        if let Some(tls_parameters) = tls_parameters {
+            stream.upgrade_tls(tls_parameters).await?;
+        }
+        Ok(stream)
+    }
+
+    #[cfg(feature = "async-std1")]
+    pub async fn connect_asyncstd1(
+        hostname: &str,
+        port: u16,
+        tls_parameters: Option<TlsParameters>,
+    ) -> Result<AsyncNetworkStream, Error> {
+        let tcp_stream = AsyncStd1TcpStream::connect((hostname, port)).await?;
+
+        let mut stream = AsyncNetworkStream::new(InnerAsyncNetworkStream::AsyncStd1Tcp(tcp_stream));
+        if let Some(tls_parameters) = tls_parameters {
+            stream.upgrade_tls(tls_parameters).await?;
+        }
+        Ok(stream)
+    }
+
     pub async fn upgrade_tls(&mut self, tls_parameters: TlsParameters) -> Result<(), Error> {
         match &self.inner {
-            #[cfg(not(any(feature = "tokio02-native-tls", feature = "tokio02-rustls-tls")))]
+            #[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");
@@ -127,6 +206,48 @@ impl AsyncNetworkStream {
                 self.inner = Self::upgrade_tokio02_tls(tcp_stream, tls_parameters).await?;
                 Ok(())
             }
+            #[cfg(all(
+                feature = "tokio1",
+                not(any(feature = "tokio1-native-tls", feature = "tokio1-rustls-tls"))
+            ))]
+            InnerAsyncNetworkStream::Tokio1Tcp(_) => {
+                let _ = tls_parameters;
+                panic!("Trying to upgrade an AsyncNetworkStream without having enabled either the tokio1-native-tls or the tokio1-rustls-tls feature");
+            }
+
+            #[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 = match tcp_stream {
+                    InnerAsyncNetworkStream::Tokio1Tcp(tcp_stream) => tcp_stream,
+                    _ => unreachable!(),
+                };
+
+                self.inner = Self::upgrade_tokio1_tls(tcp_stream, tls_parameters).await?;
+                Ok(())
+            }
+            #[cfg(all(
+                feature = "async-std1",
+                not(any(feature = "async-std1-native-tls", feature = "async-std1-rustls-tls"))
+            ))]
+            InnerAsyncNetworkStream::AsyncStd1Tcp(_) => {
+                let _ = tls_parameters;
+                panic!("Trying to upgrade an AsyncNetworkStream without having enabled either the async-std1-native-tls or the async-std1-rustls-tls feature");
+            }
+
+            #[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 = match tcp_stream {
+                    InnerAsyncNetworkStream::AsyncStd1Tcp(tcp_stream) => tcp_stream,
+                    _ => unreachable!(),
+                };
+
+                self.inner = Self::upgrade_asyncstd1_tls(tcp_stream, tls_parameters).await?;
+                Ok(())
+            }
             _ => Ok(()),
         }
     }
@@ -134,7 +255,7 @@ impl AsyncNetworkStream {
     #[allow(unused_variables)]
     #[cfg(any(feature = "tokio02-native-tls", feature = "tokio02-rustls-tls"))]
     async fn upgrade_tokio02_tls(
-        tcp_stream: TcpStream,
+        tcp_stream: Tokio02TcpStream,
         mut tls_parameters: TlsParameters,
     ) -> Result<InnerAsyncNetworkStream, Error> {
         let domain = std::mem::take(&mut tls_parameters.domain);
@@ -167,7 +288,97 @@ impl AsyncNetworkStream {
 
                     let connector = TlsConnector::from(Arc::new(config));
                     let stream = connector.connect(domain, tcp_stream).await?;
-                    Ok(InnerAsyncNetworkStream::Tokio02RustlsTls(Box::new(stream)))
+                    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);
+
+        match tls_parameters.connector {
+            #[cfg(feature = "native-tls")]
+            InnerTlsParameters::NativeTls(connector) => {
+                #[cfg(not(feature = "tokio1-native-tls"))]
+                panic!("built without the tokio1-native-tls feature");
+
+                #[cfg(feature = "tokio1-native-tls")]
+                return {
+                    use tokio1_native_tls_crate::TlsConnector;
+
+                    let connector = TlsConnector::from(connector);
+                    let stream = connector.connect(&domain, tcp_stream).await?;
+                    Ok(InnerAsyncNetworkStream::Tokio1NativeTls(stream))
+                };
+            }
+            #[cfg(feature = "rustls-tls")]
+            InnerTlsParameters::RustlsTls(config) => {
+                #[cfg(not(feature = "tokio1-rustls-tls"))]
+                panic!("built without the tokio1-rustls-tls feature");
+
+                #[cfg(feature = "tokio1-rustls-tls")]
+                return {
+                    use tokio1_rustls::{webpki::DNSNameRef, TlsConnector};
+
+                    let domain = DNSNameRef::try_from_ascii_str(&domain)?;
+
+                    let connector = TlsConnector::from(Arc::new(config));
+                    let stream = connector.connect(domain, tcp_stream).await?;
+                    Ok(InnerAsyncNetworkStream::Tokio1RustlsTls(stream))
+                };
+            }
+        }
+    }
+
+    #[allow(unused_variables)]
+    #[cfg(any(feature = "async-std1-native-tls", feature = "async-std1-rustls-tls"))]
+    async fn upgrade_asyncstd1_tls(
+        tcp_stream: AsyncStd1TcpStream,
+        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) => {
+                panic!("native-tls isn't supported with async-std yet. See https://github.com/lettre/lettre/pull/531#issuecomment-757893531");
+
+                /*
+                #[cfg(not(feature = "async-std1-native-tls"))]
+                panic!("built without the async-std1-native-tls feature");
+
+                #[cfg(feature = "async-std1-native-tls")]
+                return {
+                    use async_native_tls::TlsConnector;
+
+                    // TODO: fix
+                    let connector: TlsConnector = todo!();
+                    // let connector = TlsConnector::from(connector);
+                    let stream = connector.connect(&domain, tcp_stream).await?;
+                    Ok(InnerAsyncNetworkStream::AsyncStd1NativeTls(stream))
+                };
+                */
+            }
+            #[cfg(feature = "rustls-tls")]
+            InnerTlsParameters::RustlsTls(config) => {
+                #[cfg(not(feature = "async-std1-rustls-tls"))]
+                panic!("built without the async-std1-rustls-tls feature");
+
+                #[cfg(feature = "async-std1-rustls-tls")]
+                return {
+                    use async_rustls::{webpki::DNSNameRef, TlsConnector};
+
+                    let domain = DNSNameRef::try_from_ascii_str(&domain)?;
+
+                    let connector = TlsConnector::from(Arc::new(config));
+                    let stream = connector.connect(domain, tcp_stream).await?;
+                    Ok(InnerAsyncNetworkStream::AsyncStd1RustlsTls(stream))
                 };
             }
         }
@@ -181,15 +392,27 @@ impl AsyncNetworkStream {
             InnerAsyncNetworkStream::Tokio02NativeTls(_) => true,
             #[cfg(feature = "tokio02-rustls-tls")]
             InnerAsyncNetworkStream::Tokio02RustlsTls(_) => true,
+            #[cfg(feature = "tokio1")]
+            InnerAsyncNetworkStream::Tokio1Tcp(_) => false,
+            #[cfg(feature = "tokio1-native-tls")]
+            InnerAsyncNetworkStream::Tokio1NativeTls(_) => true,
+            #[cfg(feature = "tokio1-rustls-tls")]
+            InnerAsyncNetworkStream::Tokio1RustlsTls(_) => true,
+            #[cfg(feature = "async-std1")]
+            InnerAsyncNetworkStream::AsyncStd1Tcp(_) => false,
+            #[cfg(feature = "async-std1-native-tls")]
+            InnerAsyncNetworkStream::AsyncStd1NativeTls(_) => true,
+            #[cfg(feature = "async-std1-rustls-tls")]
+            InnerAsyncNetworkStream::AsyncStd1RustlsTls(_) => true,
             InnerAsyncNetworkStream::None => false,
         }
     }
 }
 
-impl futures_io::AsyncRead for AsyncNetworkStream {
+impl FuturesAsyncRead for AsyncNetworkStream {
     fn poll_read(
         mut self: Pin<&mut Self>,
-        cx: &mut Context,
+        cx: &mut Context<'_>,
         buf: &mut [u8],
     ) -> Poll<IoResult<usize>> {
         match self.inner {
@@ -199,16 +422,57 @@ impl futures_io::AsyncRead for AsyncNetworkStream {
             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);
+                match Pin::new(s).poll_read(cx, &mut b) {
+                    Poll::Ready(Ok(())) => Poll::Ready(Ok(b.filled().len())),
+                    Poll::Ready(Err(err)) => Poll::Ready(Err(err)),
+                    Poll::Pending => Poll::Pending,
+                }
+            }
+            #[cfg(feature = "tokio1-native-tls")]
+            InnerAsyncNetworkStream::Tokio1NativeTls(ref mut s) => {
+                let mut b = Tokio1ReadBuf::new(buf);
+                match Pin::new(s).poll_read(cx, &mut b) {
+                    Poll::Ready(Ok(())) => Poll::Ready(Ok(b.filled().len())),
+                    Poll::Ready(Err(err)) => Poll::Ready(Err(err)),
+                    Poll::Pending => Poll::Pending,
+                }
+            }
+            #[cfg(feature = "tokio1-rustls-tls")]
+            InnerAsyncNetworkStream::Tokio1RustlsTls(ref mut s) => {
+                let mut b = Tokio1ReadBuf::new(buf);
+                match Pin::new(s).poll_read(cx, &mut b) {
+                    Poll::Ready(Ok(())) => Poll::Ready(Ok(b.filled().len())),
+                    Poll::Ready(Err(err)) => Poll::Ready(Err(err)),
+                    Poll::Pending => Poll::Pending,
+                }
+            }
+            #[cfg(feature = "async-std1")]
+            InnerAsyncNetworkStream::AsyncStd1Tcp(ref mut s) => Pin::new(s).poll_read(cx, buf),
+            #[cfg(feature = "async-std1-native-tls")]
+            InnerAsyncNetworkStream::AsyncStd1NativeTls(ref mut s) => {
+                Pin::new(s).poll_read(cx, buf)
+            }
+            #[cfg(feature = "async-std1-rustls-tls")]
+            InnerAsyncNetworkStream::AsyncStd1RustlsTls(ref mut s) => {
+                Pin::new(s).poll_read(cx, buf)
+            }
             InnerAsyncNetworkStream::None => {
-                debug_assert!(false, "InnerAsyncNetworkStream::None should never be built");
+                debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
                 Poll::Ready(Ok(0))
             }
         }
     }
 }
 
-impl futures_io::AsyncWrite for AsyncNetworkStream {
-    fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context, buf: &[u8]) -> Poll<IoResult<usize>> {
+impl FuturesAsyncWrite for AsyncNetworkStream {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<IoResult<usize>> {
         match self.inner {
             #[cfg(feature = "tokio02")]
             InnerAsyncNetworkStream::Tokio02Tcp(ref mut s) => Pin::new(s).poll_write(cx, buf),
@@ -216,14 +480,30 @@ impl futures_io::AsyncWrite for AsyncNetworkStream {
             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")]
+            InnerAsyncNetworkStream::Tokio1NativeTls(ref mut s) => Pin::new(s).poll_write(cx, buf),
+            #[cfg(feature = "tokio1-rustls-tls")]
+            InnerAsyncNetworkStream::Tokio1RustlsTls(ref mut s) => Pin::new(s).poll_write(cx, buf),
+            #[cfg(feature = "async-std1")]
+            InnerAsyncNetworkStream::AsyncStd1Tcp(ref mut s) => Pin::new(s).poll_write(cx, buf),
+            #[cfg(feature = "async-std1-native-tls")]
+            InnerAsyncNetworkStream::AsyncStd1NativeTls(ref mut s) => {
+                Pin::new(s).poll_write(cx, buf)
+            }
+            #[cfg(feature = "async-std1-rustls-tls")]
+            InnerAsyncNetworkStream::AsyncStd1RustlsTls(ref mut s) => {
+                Pin::new(s).poll_write(cx, buf)
+            }
             InnerAsyncNetworkStream::None => {
-                debug_assert!(false, "InnerAsyncNetworkStream::None should never be built");
+                debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
                 Poll::Ready(Ok(0))
             }
         }
     }
 
-    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<IoResult<()>> {
+    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),
@@ -231,14 +511,49 @@ impl futures_io::AsyncWrite for AsyncNetworkStream {
             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")]
+            InnerAsyncNetworkStream::Tokio1NativeTls(ref mut s) => Pin::new(s).poll_flush(cx),
+            #[cfg(feature = "tokio1-rustls-tls")]
+            InnerAsyncNetworkStream::Tokio1RustlsTls(ref mut s) => Pin::new(s).poll_flush(cx),
+            #[cfg(feature = "async-std1")]
+            InnerAsyncNetworkStream::AsyncStd1Tcp(ref mut s) => Pin::new(s).poll_flush(cx),
+            #[cfg(feature = "async-std1-native-tls")]
+            InnerAsyncNetworkStream::AsyncStd1NativeTls(ref mut s) => Pin::new(s).poll_flush(cx),
+            #[cfg(feature = "async-std1-rustls-tls")]
+            InnerAsyncNetworkStream::AsyncStd1RustlsTls(ref mut s) => Pin::new(s).poll_flush(cx),
             InnerAsyncNetworkStream::None => {
-                debug_assert!(false, "InnerAsyncNetworkStream::None should never be built");
+                debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
                 Poll::Ready(Ok(()))
             }
         }
     }
 
-    fn poll_close(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<IoResult<()>> {
-        Poll::Ready(self.shutdown(Shutdown::Write))
+    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")]
+            InnerAsyncNetworkStream::Tokio1NativeTls(ref mut s) => Pin::new(s).poll_shutdown(cx),
+            #[cfg(feature = "tokio1-rustls-tls")]
+            InnerAsyncNetworkStream::Tokio1RustlsTls(ref mut s) => Pin::new(s).poll_shutdown(cx),
+            #[cfg(feature = "async-std1")]
+            InnerAsyncNetworkStream::AsyncStd1Tcp(ref mut s) => Pin::new(s).poll_close(cx),
+            #[cfg(feature = "async-std1-native-tls")]
+            InnerAsyncNetworkStream::AsyncStd1NativeTls(ref mut s) => Pin::new(s).poll_close(cx),
+            #[cfg(feature = "async-std1-rustls-tls")]
+            InnerAsyncNetworkStream::AsyncStd1RustlsTls(ref mut s) => Pin::new(s).poll_close(cx),
+            InnerAsyncNetworkStream::None => {
+                debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
+                Poll::Ready(Ok(()))
+            }
+        }
     }
 }

src/transport/smtp/client/connection.rs

@@ -7,6 +7,7 @@ use std::{
 
 use super::{ClientCodec, NetworkStream, TlsParameters};
 use crate::{
+    address::Envelope,
     transport::smtp::{
         authentication::{Credentials, Mechanism},
         commands::*,
@@ -14,7 +15,6 @@ use crate::{
         extension::{ClientId, Extension, MailBodyParameter, MailParameter, ServerInfo},
         response::{parse_response, Response},
     },
-    Envelope,
 };
 
 #[cfg(feature = "tracing")]
@@ -82,9 +82,32 @@ impl SmtpConnection {
         // Mail
         let mut mail_options = vec![];
 
-        if self.server_info().supports_feature(Extension::EightBitMime) {
+        // Internationalization handling
+        //
+        // * 8BITMIME: https://tools.ietf.org/html/rfc6152
+        // * SMTPUTF8: https://tools.ietf.org/html/rfc653
+
+        // Check for non-ascii addresses and use the SMTPUTF8 option if any.
+        if envelope.has_non_ascii_addresses() {
+            if !self.server_info().supports_feature(Extension::SmtpUtfEight) {
+                // don't try to send non-ascii addresses (per RFC)
+                return Err(Error::Client(
+                    "Envelope contains non-ascii chars but server does not support SMTPUTF8",
+                ));
+            }
+            mail_options.push(MailParameter::SmtpUtfEight);
+        }
+
+        // Check for non-ascii content in message
+        if !email.is_ascii() {
+            if !self.server_info().supports_feature(Extension::EightBitMime) {
+                return Err(Error::Client(
+                    "Message contains non-ascii chars but server does not support 8BITMIME",
+                ));
+            }
             mail_options.push(MailParameter::Body(MailBodyParameter::EightBitMime));
         }
+
         try_smtp!(
             self.command(Mail::new(envelope.from().cloned(), mail_options)),
             self
@@ -255,11 +278,11 @@ impl SmtpConnection {
                     return Err(response.into());
                 }
                 Err(nom::Err::Failure(e)) => {
-                    return Err(Error::Parsing(e.1));
+                    return Err(Error::Parsing(e.code));
                 }
                 Err(nom::Err::Incomplete(_)) => { /* read more */ }
                 Err(nom::Err::Error(e)) => {
-                    return Err(Error::Parsing(e.1));
+                    return Err(Error::Parsing(e.code));
                 }
             }
         }

src/transport/smtp/client/mod.rs

@@ -3,30 +3,33 @@
 //! `SmtpConnection` allows manually sending SMTP commands.
 //!
 //! ```rust,no_run
+//! # use std::error::Error;
+//!
 //! # #[cfg(feature = "smtp-transport")]
-//! # {
+//! # fn main() -> Result<(), Box<dyn Error>> {
 //! use lettre::transport::smtp::{SMTP_PORT, extension::ClientId, commands::*, client::SmtpConnection};
 //!
 //! let hello = ClientId::Domain("my_hostname".to_string());
-//! let mut client = SmtpConnection::connect(&("localhost", SMTP_PORT), None, &hello, None).unwrap();
+//! let mut client = SmtpConnection::connect(&("localhost", SMTP_PORT), None, &hello, None)?;
 //! client.command(
-//!         Mail::new(Some("user@example.com".parse().unwrap()), vec![])
-//!     ).unwrap();
+//!         Mail::new(Some("user@example.com".parse()?), vec![])
+//!     )?;
 //! client.command(
-//!         Rcpt::new("user@example.org".parse().unwrap(), vec![])
-//!       ).unwrap();
-//! client.command(Data).unwrap();
-//! client.message("Test email".as_bytes()).unwrap();
-//! client.command(Quit).unwrap();
+//!         Rcpt::new("user@example.org".parse()?, vec![])
+//!       )?;
+//! client.command(Data)?;
+//! client.message("Test email".as_bytes())?;
+//! client.command(Quit)?;
+//! # Ok(())
 //! # }
 //! ```
 
 #[cfg(feature = "serde")]
 use std::fmt::Debug;
 
-#[cfg(feature = "tokio02")]
+#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
 pub(crate) use self::async_connection::AsyncSmtpConnection;
-#[cfg(feature = "tokio02")]
+#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
 pub(crate) use self::async_net::AsyncNetworkStream;
 use self::net::NetworkStream;
 #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
@@ -34,12 +37,12 @@ pub(super) use self::tls::InnerTlsParameters;
 pub use self::{
     connection::SmtpConnection,
     mock::MockStream,
-    tls::{Tls, TlsParameters},
+    tls::{Certificate, Tls, TlsParameters, TlsParametersBuilder},
 };
 
-#[cfg(feature = "tokio02")]
+#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
 mod async_connection;
-#[cfg(feature = "tokio02")]
+#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
 mod async_net;
 mod connection;
 mod mock;
@@ -49,7 +52,7 @@ mod tls;
 /// The codec used for transparency
 #[derive(Default, Clone, Copy, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct ClientCodec {
+struct ClientCodec {
     escape_count: u8,
 }
 

src/transport/smtp/client/net.rs

@@ -23,6 +23,9 @@ pub struct NetworkStream {
 }
 
 /// Represents the different types of underlying network streams
+// usually only one TLS backend at a time is going to be enabled,
+// so clippy::large_enum_variant doesn't make sense here
+#[allow(clippy::large_enum_variant)]
 enum InnerNetworkStream {
     /// Plain TCP stream
     Tcp(TcpStream),
@@ -31,7 +34,7 @@ enum InnerNetworkStream {
     NativeTls(TlsStream<TcpStream>),
     /// Encrypted TCP stream
     #[cfg(feature = "rustls-tls")]
-    RustlsTls(Box<StreamOwned<ClientSession, TcpStream>>),
+    RustlsTls(StreamOwned<ClientSession, TcpStream>),
     /// Mock stream
     Mock(MockStream),
 }
@@ -150,7 +153,7 @@ impl NetworkStream {
                     tcp_stream,
                 );
 
-                InnerNetworkStream::RustlsTls(Box::new(stream))
+                InnerNetworkStream::RustlsTls(stream)
             }
         })
     }

src/transport/smtp/client/tls.rs

@@ -1,10 +1,14 @@
-#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-use crate::transport::smtp::error::Error;
+#[cfg(feature = "rustls-tls")]
+use std::sync::Arc;
 
 #[cfg(feature = "native-tls")]
 use native_tls::{Protocol, TlsConnector};
 #[cfg(feature = "rustls-tls")]
-use rustls::ClientConfig;
+use rustls::{ClientConfig, RootCertStore, ServerCertVerified, ServerCertVerifier, TLSError};
+#[cfg(feature = "rustls-tls")]
+use webpki::DNSNameRef;
+
+use crate::transport::smtp::error::Error;
 
 /// Accepted protocols by default.
 /// This removes TLS 1.0 and 1.1 compared to tls-native defaults.
@@ -38,6 +42,141 @@ pub struct TlsParameters {
     pub(super) domain: String,
 }
 
+/// Builder for `TlsParameters`
+#[derive(Clone)]
+pub struct TlsParametersBuilder {
+    domain: String,
+    root_certs: Vec<Certificate>,
+    accept_invalid_hostnames: bool,
+    accept_invalid_certs: bool,
+}
+
+impl TlsParametersBuilder {
+    /// Creates a new builder for `TlsParameters`
+    pub fn new(domain: String) -> Self {
+        Self {
+            domain,
+            root_certs: Vec::new(),
+            accept_invalid_hostnames: false,
+            accept_invalid_certs: false,
+        }
+    }
+
+    /// Add a custom root certificate
+    ///
+    /// Can be used to safely connect to a server using a self signed certificate, for example.
+    pub fn add_root_certificate(mut self, cert: Certificate) -> Self {
+        self.root_certs.push(cert);
+        self
+    }
+
+    /// Controls whether certificates with an invalid hostname are accepted
+    ///
+    /// Defaults to `false`.
+    ///
+    /// # Warning
+    ///
+    /// You should think very carefully before using this method.
+    /// If hostname verification is disabled *any* valid certificate,
+    /// including those from other sites, are trusted.
+    ///
+    /// This method introduces significant vulnerabilities to man-in-the-middle attacks.
+    ///
+    /// Hostname verification can only be disabled with the `native-tls` TLS backend.
+    #[cfg(feature = "native-tls")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "native-tls")))]
+    pub fn dangerous_accept_invalid_hostnames(mut self, accept_invalid_hostnames: bool) -> Self {
+        self.accept_invalid_hostnames = accept_invalid_hostnames;
+        self
+    }
+
+    /// Controls whether invalid certificates are accepted
+    ///
+    /// Defaults to `false`.
+    ///
+    /// # Warning
+    ///
+    /// You should think very carefully before using this method.
+    /// If certificate verification is disabled, *any* certificate
+    /// is trusted for use, including:
+    ///
+    /// * Self signed certificates
+    /// * Certificates from different hostnames
+    /// * Expired certificates
+    ///
+    /// This method should only be used as a last resort, as it introduces
+    /// significant vulnerabilities to man-in-the-middle attacks.
+    pub fn dangerous_accept_invalid_certs(mut self, accept_invalid_certs: bool) -> Self {
+        self.accept_invalid_certs = accept_invalid_certs;
+        self
+    }
+
+    /// Creates a new `TlsParameters` using native-tls or rustls
+    /// 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"))]
+        return self.build_rustls();
+
+        #[cfg(feature = "native-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
+    #[cfg(feature = "native-tls")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "native-tls")))]
+    pub fn build_native(self) -> Result<TlsParameters, Error> {
+        let mut tls_builder = TlsConnector::builder();
+
+        for cert in self.root_certs {
+            tls_builder.add_root_certificate(cert.native_tls);
+        }
+        tls_builder.danger_accept_invalid_hostnames(self.accept_invalid_hostnames);
+        tls_builder.danger_accept_invalid_certs(self.accept_invalid_certs);
+
+        tls_builder.min_protocol_version(Some(DEFAULT_TLS_MIN_PROTOCOL));
+        let connector = tls_builder.build()?;
+        Ok(TlsParameters {
+            connector: InnerTlsParameters::NativeTls(connector),
+            domain: self.domain,
+        })
+    }
+
+    /// Creates a new `TlsParameters` using rustls with the provided configuration
+    #[cfg(feature = "rustls-tls")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "rustls-tls")))]
+    pub fn build_rustls(self) -> Result<TlsParameters, Error> {
+        use webpki_roots::TLS_SERVER_ROOTS;
+
+        let mut tls = ClientConfig::new();
+
+        for cert in self.root_certs {
+            for rustls_cert in cert.rustls {
+                tls.root_store
+                    .add(&rustls_cert)
+                    .map_err(|_| Error::InvalidCertificate)?;
+            }
+        }
+        if self.accept_invalid_certs {
+            tls.dangerous()
+                .set_certificate_verifier(Arc::new(InvalidCertsVerifier {}));
+        }
+
+        tls.root_store.add_server_trust_anchors(&TLS_SERVER_ROOTS);
+        Ok(TlsParameters {
+            connector: InnerTlsParameters::RustlsTls(tls),
+            domain: self.domain,
+        })
+    }
+}
+
 #[derive(Clone)]
 pub enum InnerTlsParameters {
     #[cfg(feature = "native-tls")]
@@ -50,49 +189,95 @@ impl TlsParameters {
     /// Creates a new `TlsParameters` using native-tls or rustls
     /// 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"))))]
     pub fn new(domain: String) -> Result<Self, Error> {
-        #[cfg(feature = "native-tls")]
-        return Self::new_native(domain);
-
-        #[cfg(not(feature = "native-tls"))]
-        return Self::new_rustls(domain);
+        TlsParametersBuilder::new(domain).build()
     }
 
-    #[cfg(any(feature = "tokio02-native-tls", feature = "tokio02-rustls-tls"))]
-    pub(crate) fn new_tokio02(domain: String) -> Result<Self, Error> {
-        #[cfg(feature = "tokio02-native-tls")]
-        return Self::new_native(domain);
-
-        #[cfg(not(feature = "tokio02-native-tls"))]
-        return Self::new_rustls(domain);
+    pub fn builder(domain: String) -> TlsParametersBuilder {
+        TlsParametersBuilder::new(domain)
     }
 
     /// Creates a new `TlsParameters` using native-tls
     #[cfg(feature = "native-tls")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "native-tls")))]
     pub fn new_native(domain: String) -> Result<Self, Error> {
-        let mut tls_builder = TlsConnector::builder();
-        tls_builder.min_protocol_version(Some(DEFAULT_TLS_MIN_PROTOCOL));
-        let connector = tls_builder.build()?;
-        Ok(Self {
-            connector: InnerTlsParameters::NativeTls(connector),
-            domain,
-        })
+        TlsParametersBuilder::new(domain).build_native()
     }
 
     /// Creates a new `TlsParameters` using rustls
     #[cfg(feature = "rustls-tls")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "rustls-tls")))]
     pub fn new_rustls(domain: String) -> Result<Self, Error> {
-        use webpki_roots::TLS_SERVER_ROOTS;
-
-        let mut tls = ClientConfig::new();
-        tls.root_store.add_server_trust_anchors(&TLS_SERVER_ROOTS);
-        Ok(Self {
-            connector: InnerTlsParameters::RustlsTls(tls),
-            domain,
-        })
+        TlsParametersBuilder::new(domain).build_rustls()
     }
 
     pub fn domain(&self) -> &str {
         &self.domain
     }
 }
+
+/// A client certificate that can be used with [`TlsParametersBuilder::add_root_certificate`]
+#[derive(Clone)]
+#[allow(missing_copy_implementations)]
+pub struct Certificate {
+    #[cfg(feature = "native-tls")]
+    native_tls: native_tls::Certificate,
+    #[cfg(feature = "rustls-tls")]
+    rustls: Vec<rustls::Certificate>,
+}
+
+impl Certificate {
+    /// Create a `Certificate` from a DER encoded certificate
+    pub fn from_der(der: Vec<u8>) -> Result<Self, Error> {
+        #[cfg(feature = "native-tls")]
+        let native_tls_cert =
+            native_tls::Certificate::from_der(&der).map_err(|_| Error::InvalidCertificate)?;
+
+        Ok(Self {
+            #[cfg(feature = "native-tls")]
+            native_tls: native_tls_cert,
+            #[cfg(feature = "rustls-tls")]
+            rustls: vec![rustls::Certificate(der)],
+        })
+    }
+
+    /// Create a `Certificate` from a PEM encoded certificate
+    pub fn from_pem(pem: &[u8]) -> Result<Self, Error> {
+        #[cfg(feature = "native-tls")]
+        let native_tls_cert =
+            native_tls::Certificate::from_pem(pem).map_err(|_| Error::InvalidCertificate)?;
+
+        #[cfg(feature = "rustls-tls")]
+        let rustls_cert = {
+            use rustls::internal::pemfile;
+            use std::io::Cursor;
+
+            let mut pem = Cursor::new(pem);
+            pemfile::certs(&mut pem).map_err(|_| Error::InvalidCertificate)?
+        };
+
+        Ok(Self {
+            #[cfg(feature = "native-tls")]
+            native_tls: native_tls_cert,
+            #[cfg(feature = "rustls-tls")]
+            rustls: rustls_cert,
+        })
+    }
+}
+
+#[cfg(feature = "rustls-tls")]
+struct InvalidCertsVerifier;
+
+#[cfg(feature = "rustls-tls")]
+impl ServerCertVerifier for InvalidCertsVerifier {
+    fn verify_server_cert(
+        &self,
+        _roots: &RootCertStore,
+        _presented_certs: &[rustls::Certificate],
+        _dns_name: DNSNameRef<'_>,
+        _ocsp_response: &[u8],
+    ) -> Result<ServerCertVerified, TLSError> {
+        Ok(ServerCertVerified::assertion())
+    }
+}

src/transport/smtp/commands.rs

@@ -9,10 +9,7 @@ use crate::{
     },
     Address,
 };
-use std::{
-    convert::AsRef,
-    fmt::{self, Display, Formatter},
-};
+use std::fmt::{self, Display, Formatter};
 
 /// EHLO command
 #[derive(PartialEq, Clone, Debug)]
@@ -22,7 +19,7 @@ pub struct Ehlo {
 }
 
 impl Display for Ehlo {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "EHLO {}\r\n", self.client_id)
     }
 }
@@ -40,7 +37,7 @@ impl Ehlo {
 pub struct Starttls;
 
 impl Display for Starttls {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.write_str("STARTTLS\r\n")
     }
 }
@@ -54,7 +51,7 @@ pub struct Mail {
 }
 
 impl Display for Mail {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(
             f,
             "MAIL FROM:<{}>",
@@ -83,7 +80,7 @@ pub struct Rcpt {
 }
 
 impl Display for Rcpt {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "RCPT TO:<{}>", self.recipient)?;
         for parameter in &self.parameters {
             write!(f, " {}", parameter)?;
@@ -108,7 +105,7 @@ impl Rcpt {
 pub struct Data;
 
 impl Display for Data {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.write_str("DATA\r\n")
     }
 }
@@ -119,7 +116,7 @@ impl Display for Data {
 pub struct Quit;
 
 impl Display for Quit {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.write_str("QUIT\r\n")
     }
 }
@@ -130,7 +127,7 @@ impl Display for Quit {
 pub struct Noop;
 
 impl Display for Noop {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.write_str("NOOP\r\n")
     }
 }
@@ -143,7 +140,7 @@ pub struct Help {
 }
 
 impl Display for Help {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.write_str("HELP")?;
         if let Some(argument) = &self.argument {
             write!(f, " {}", argument)?;
@@ -167,7 +164,7 @@ pub struct Vrfy {
 }
 
 impl Display for Vrfy {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "VRFY {}\r\n", self.argument)
     }
 }
@@ -187,7 +184,7 @@ pub struct Expn {
 }
 
 impl Display for Expn {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "EXPN {}\r\n", self.argument)
     }
 }
@@ -205,7 +202,7 @@ impl Expn {
 pub struct Rset;
 
 impl Display for Rset {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.write_str("RSET\r\n")
     }
 }
@@ -221,7 +218,7 @@ pub struct Auth {
 }
 
 impl Display for Auth {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         let encoded_response = self.response.as_ref().map(base64::encode);
 
         if self.mechanism.supports_initial_response() {
@@ -338,7 +335,7 @@ mod test {
             "RCPT TO:<test@example.com>\r\n"
         );
         assert_eq!(
-            format!("{}", Rcpt::new(email.clone(), vec![rcpt_parameter])),
+            format!("{}", Rcpt::new(email, vec![rcpt_parameter])),
             "RCPT TO:<test@example.com> TEST=value\r\n"
         );
         assert_eq!(format!("{}", Quit), "QUIT\r\n");
@@ -369,7 +366,7 @@ mod test {
         assert_eq!(
             format!(
                 "{}",
-                Auth::new(Mechanism::Login, credentials.clone(), None).unwrap()
+                Auth::new(Mechanism::Login, credentials, None).unwrap()
             ),
             "AUTH LOGIN\r\n"
         );

src/transport/smtp/error.rs

@@ -25,7 +25,7 @@ pub enum Error {
     ResponseParsing(&'static str),
     /// Error parsing a base64 string in response
     ChallengeParsing(DecodeError),
-    /// Error parsing UTF8in response
+    /// Error parsing UTF8 in response
     Utf8Parsing(FromUtf8Error),
     /// Internal client error
     Client(&'static str),
@@ -35,29 +35,35 @@ pub enum Error {
     Io(io::Error),
     /// TLS error
     #[cfg(feature = "native-tls")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "native-tls")))]
     Tls(native_tls::Error),
     /// Parsing error
     Parsing(nom::error::ErrorKind),
     /// Invalid hostname
     #[cfg(feature = "rustls-tls")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "rustls-tls")))]
     InvalidDNSName(webpki::InvalidDNSNameError),
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
+    InvalidCertificate,
     #[cfg(feature = "r2d2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "r2d2")))]
     Pool(r2d2::Error),
 }
 
 impl Display for Error {
-    fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), fmt::Error> {
         match *self {
             // Try to display the first line of the server's response that usually
             // contains a short humanly readable error message
-            Transient(ref err) => fmt.write_str(match err.first_line() {
-                Some(line) => line,
-                None => "transient error during SMTP transaction",
-            }),
-            Permanent(ref err) => fmt.write_str(match err.first_line() {
-                Some(line) => line,
-                None => "permanent error during SMTP transaction",
-            }),
+            Transient(ref err) => fmt.write_str(
+                err.first_line()
+                    .unwrap_or("transient error during SMTP transaction"),
+            ),
+            Permanent(ref err) => fmt.write_str(
+                err.first_line()
+                    .unwrap_or("permanent error during SMTP transaction"),
+            ),
             ResponseParsing(err) => fmt.write_str(err),
             ChallengeParsing(ref err) => err.fmt(fmt),
             Utf8Parsing(ref err) => err.fmt(fmt),
@@ -69,6 +75,8 @@ impl Display for Error {
             Parsing(ref err) => fmt.write_str(err.description()),
             #[cfg(feature = "rustls-tls")]
             InvalidDNSName(ref err) => err.fmt(fmt),
+            #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+            InvalidCertificate => fmt.write_str("invalid certificate"),
             #[cfg(feature = "r2d2")]
             Pool(ref err) => err.fmt(fmt),
         }
@@ -101,12 +109,12 @@ impl From<native_tls::Error> for Error {
     }
 }
 
-impl From<nom::Err<(&str, nom::error::ErrorKind)>> for Error {
-    fn from(err: nom::Err<(&str, nom::error::ErrorKind)>) -> Error {
+impl From<nom::Err<nom::error::Error<&str>>> for Error {
+    fn from(err: nom::Err<nom::error::Error<&str>>) -> Error {
         Parsing(match err {
             nom::Err::Incomplete(_) => nom::error::ErrorKind::Complete,
-            nom::Err::Failure((_, k)) => k,
-            nom::Err::Error((_, k)) => k,
+            nom::Err::Failure(e) => e.code,
+            nom::Err::Error(e) => e.code,
         })
     }
 }

src/transport/smtp/extension.rs

@@ -48,7 +48,7 @@ impl Default for ClientId {
 }
 
 impl Display for ClientId {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match *self {
             Self::Domain(ref value) => f.write_str(value),
             Self::Ipv4(ref value) => write!(f, "[{}]", value),
@@ -71,22 +71,22 @@ impl ClientId {
 pub enum Extension {
     /// 8BITMIME keyword
     ///
-    /// RFC 6152: https://tools.ietf.org/html/rfc6152
+    /// Defined in [RFC 6152](https://tools.ietf.org/html/rfc6152)
     EightBitMime,
     /// SMTPUTF8 keyword
     ///
-    /// RFC 6531: https://tools.ietf.org/html/rfc6531
+    /// Defined in [RFC 6531](https://tools.ietf.org/html/rfc6531)
     SmtpUtfEight,
     /// STARTTLS keyword
     ///
-    /// RFC 2487: https://tools.ietf.org/html/rfc2487
+    /// Defined in [RFC 2487](https://tools.ietf.org/html/rfc2487)
     StartTls,
     /// AUTH mechanism
     Authentication(Mechanism),
 }
 
 impl Display for Extension {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match *self {
             Extension::EightBitMime => f.write_str("8BITMIME"),
             Extension::SmtpUtfEight => f.write_str("SMTPUTF8"),
@@ -111,7 +111,7 @@ pub struct ServerInfo {
 }
 
 impl Display for ServerInfo {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         let features = if self.features.is_empty() {
             "no supported features".to_string()
         } else {
@@ -215,7 +215,7 @@ pub enum MailParameter {
 }
 
 impl Display for MailParameter {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match *self {
             MailParameter::Body(ref value) => write!(f, "BODY={}", value),
             MailParameter::Size(size) => write!(f, "SIZE={}", size),
@@ -243,7 +243,7 @@ pub enum MailBodyParameter {
 }
 
 impl Display for MailBodyParameter {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match *self {
             MailBodyParameter::SevenBit => f.write_str("7BIT"),
             MailBodyParameter::EightBitMime => f.write_str("8BITMIME"),
@@ -265,7 +265,7 @@ pub enum RcptParameter {
 }
 
 impl Display for RcptParameter {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match *self {
             RcptParameter::Other {
                 ref keyword,
@@ -320,7 +320,7 @@ mod test {
                 "{}",
                 ServerInfo {
                     name: "name".to_string(),
-                    features: eightbitmime.clone(),
+                    features: eightbitmime,
                 }
             ),
             "name with {EightBitMime}".to_string()
@@ -347,7 +347,7 @@ mod test {
                 "{}",
                 ServerInfo {
                     name: "name".to_string(),
-                    features: plain.clone(),
+                    features: plain,
                 }
             ),
             "name with {Authentication(Plain)}".to_string()

src/transport/smtp/mod.rs

@@ -31,133 +31,98 @@
 //! This is the most basic example of usage:
 //!
 //! ```rust,no_run
-//! # #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-//! # {
+//! # #[cfg(all(feature = "builder", any(feature = "native-tls", feature = "rustls-tls")))]
+//! # fn test() -> Result<(), Box<dyn std::error::Error>> {
 //! use lettre::{Message, Transport, SmtpTransport};
 //!
 //! 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())
+//!     .from("NoBody <nobody@domain.tld>".parse()?)
+//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
+//!     .to("Hei <hei@domain.tld>".parse()?)
 //!     .subject("Happy new year")
-//!     .body("Be happy!")
-//!     .unwrap();
+//!     .body(String::from("Be happy!"))?;
 //!
 //! // Create TLS transport on port 465
-//! let sender = SmtpTransport::relay("smtp.example.com")
-//!     .expect("relay valid")
+//! let sender = SmtpTransport::relay("smtp.example.com")?
 //!     .build();
 //! // Send the email via remote relay
 //! let result = sender.send(&email);
 //! assert!(result.is_ok());
+//! # Ok(())
 //! # }
 //! ```
-
-//! #### Complete example
 //!
-//! ```todo
-//! # #[cfg(feature = "smtp-transport")]
-//! # {
-//! use lettre::transport::smtp::authentication::{Credentials, Mechanism};
-//! use lettre::{Email, Envelope, Transport, SmtpClient};
-//! use lettre::transport::smtp::extension::ClientId;
+//! #### Authentication
 //!
-//! let email_1 = Email::new(
-//!     Envelope::new(
-//!         Some(EmailAddress::new("user@localhost".to_string()).unwrap()),
-//!         vec![EmailAddress::new("root@localhost".to_string()).unwrap()],
-//!     ).unwrap(),
-//!     "id1".to_string(),
-//!     "Hello world".to_string().into_bytes(),
-//! );
+//! Example with authentication and connection pool:
 //!
-//! let email_2 = Email::new(
-//!     Envelope::new(
-//!         Some(EmailAddress::new("user@localhost".to_string()).unwrap()),
-//!         vec![EmailAddress::new("root@localhost".to_string()).unwrap()],
-//!     ).unwrap(),
-//!     "id2".to_string(),
-//!     "Hello world a second time".to_string().into_bytes(),
-//! );
+//! ```rust,no_run
+//! # #[cfg(all(feature = "builder", any(feature = "native-tls", feature = "rustls-tls")))]
+//! # fn test() -> Result<(), Box<dyn std::error::Error>> {
+//! use lettre::{Message, Transport, SmtpTransport, transport::smtp::{PoolConfig, authentication::{Credentials, Mechanism}}};
 //!
-//! // Connect to a remote server on a custom port
-//! let mut mailer = SmtpClient::new_simple("server.tld").unwrap()
-//!    // Set the name sent during EHLO/HELO, default is `localhost`
-//!    .hello_name(ClientId::Domain("my.hostname.tld".to_string()))
-//!    // Add credentials for authentication
-//!    .credentials(Credentials::new("username".to_string(), "password".to_string()))
-//!    // Enable SMTPUTF8 if the server supports it
-//!    .smtp_utf8(true)
-//!    // Configure expected authentication mechanism
-//!    .authentication_mechanism(Mechanism::Plain)
-//!    // Enable connection reuse
-//!    .connection_reuse(ConnectionReuseParameters::ReuseUnlimited).transport();
+//! 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 result_1 = mailer.send(&email_1);
-//! assert!(result_1.is_ok());
+//! // Create TLS transport on port 587 with STARTTLS
+//! let sender = SmtpTransport::starttls_relay("smtp.example.com")?
+//!     // Add credentials for authentication
+//!     .credentials(Credentials::new("username".to_string(), "password".to_string()))
+//!     // Configure expected authentication mechanism
+//!     .authentication(vec![Mechanism::Plain])
+//!     // Connection pool settings
+//!     .pool_config( PoolConfig::new().max_size(20))
+//!     .build();
 //!
-//! // The second email will use the same connection
-//! let result_2 = mailer.send(&email_2);
-//! assert!(result_2.is_ok());
-//!
-//! // Explicitly close the SMTP transaction as we enabled connection reuse
-//! mailer.close();
+//! // Send the email via remote relay
+//! let result = sender.send(&email);
+//! assert!(result.is_ok());
+//! # Ok(())
 //! # }
 //! ```
 //!
 //! You can specify custom TLS settings:
 //!
-//! ```todo
-//! # #[cfg(feature = "native-tls")]
-//! # {
-//! use lettre::{
-//!     ClientSecurity, ClientTlsParameters, EmailAddress, Envelope,
-//!     Email, SmtpClient, Transport,
-//! };
-//! use lettre::transport::smtp::authentication::{Credentials, Mechanism};
-//! use lettre::transport::smtp::ConnectionReuseParameters;
-//! use native_tls::{Protocol, TlsConnector};
+//! ```rust,no_run
+//! # #[cfg(all(feature = "builder", any(feature = "native-tls", feature = "rustls-tls")))]
+//! # fn test() -> Result<(), Box<dyn std::error::Error>> {
+//! use lettre::{Message, Transport, SmtpTransport, transport::smtp::client::{TlsParameters, Tls}};
 //!
-//!     let email = Email::new(
-//!         Envelope::new(
-//!             Some(EmailAddress::new("user@localhost".to_string()).unwrap()),
-//!             vec![EmailAddress::new("root@localhost".to_string()).unwrap()],
-//!         ).unwrap(),
-//!         "message_id".to_string(),
-//!         "Hello world".to_string().into_bytes(),
-//!     );
+//! 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 mut tls_builder = TlsConnector::builder();
-//!     tls_builder.min_protocol_version(Some(Protocol::Tlsv10));
-//!     let tls_parameters =
-//!         ClientTlsParameters::new(
-//!             "smtp.example.com".to_string(),
-//!             tls_builder.build().unwrap()
-//!         );
+//! // Custom TLS configuration
+//! let tls = TlsParameters::builder("smtp.example.com".to_string())
+//!           .dangerous_accept_invalid_certs(true).build()?;
 //!
-//!     let mut mailer = SmtpClient::new(
-//!         ("smtp.example.com", 465), ClientSecurity::Wrapper(tls_parameters)
-//!     ).unwrap()
-//!         .authentication_mechanism(Mechanism::Login)
-//!         .credentials(Credentials::new(
-//!             "example_username".to_string(), "example_password".to_string()
-//!         ))
-//!         .connection_reuse(ConnectionReuseParameters::ReuseUnlimited)
-//!         .transport();
+//! // Create TLS transport on port 465
+//! let sender = SmtpTransport::relay("smtp.example.com")?
+//!     // Custom TLS configuration
+//!     .tls(Tls::Required(tls))
+//!     .build();
 //!
-//!     let result = mailer.send(&email);
-//!
-//!     assert!(result.is_ok());
-//!
-//!     mailer.close();
+//! // Send the email via remote relay
+//! let result = sender.send(&email);
+//! assert!(result.is_ok());
+//! # Ok(())
 //! # }
 //! ```
-//!
 
-#[cfg(feature = "tokio02")]
+#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
 pub use self::async_transport::{
-    AsyncSmtpConnector, AsyncSmtpTransport, AsyncSmtpTransportBuilder, Tokio02Connector,
+    AsyncSmtpConnector, AsyncSmtpTransport, AsyncSmtpTransportBuilder,
 };
+#[cfg(feature = "r2d2")]
+pub use self::pool::PoolConfig;
+#[cfg(feature = "r2d2")]
 pub(crate) use self::transport::SmtpClient;
 pub use self::{
     error::Error,
@@ -174,7 +139,20 @@ use crate::transport::smtp::{
 use client::Tls;
 use std::time::Duration;
 
+#[doc(hidden)]
+#[allow(deprecated)]
+#[cfg(feature = "async-std1")]
+pub use self::async_transport::AsyncStd1Connector;
+#[doc(hidden)]
+#[allow(deprecated)]
 #[cfg(feature = "tokio02")]
+pub use self::async_transport::Tokio02Connector;
+#[doc(hidden)]
+#[allow(deprecated)]
+#[cfg(feature = "tokio1")]
+pub use self::async_transport::Tokio1Connector;
+
+#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
 mod async_transport;
 pub mod authentication;
 pub mod client;
@@ -182,7 +160,7 @@ pub mod commands;
 mod error;
 pub mod extension;
 #[cfg(feature = "r2d2")]
-pub mod pool;
+mod pool;
 pub mod response;
 mod transport;
 pub mod util;
@@ -197,7 +175,7 @@ pub const SMTP_PORT: u16 = 25;
 pub const SUBMISSION_PORT: u16 = 587;
 /// Default submission over TLS port
 ///
-/// https://tools.ietf.org/html/rfc8314
+/// Defined in [RFC8314](https://tools.ietf.org/html/rfc8314)
 pub const SUBMISSIONS_PORT: u16 = 465;
 
 /// Default timeout

src/transport/smtp/pool.rs

@@ -1,5 +1,78 @@
+use std::time::Duration;
+
 use crate::transport::smtp::{client::SmtpConnection, error::Error, SmtpClient};
-use r2d2::ManageConnection;
+
+use r2d2::{ManageConnection, Pool};
+
+/// Configuration for a connection pool
+#[derive(Debug, Clone)]
+#[allow(missing_copy_implementations)]
+#[cfg_attr(docsrs, doc(cfg(feature = "r2d2")))]
+pub struct PoolConfig {
+    min_idle: u32,
+    max_size: u32,
+    connection_timeout: Duration,
+    idle_timeout: Duration,
+}
+
+impl PoolConfig {
+    /// Create a new pool configuration with default values
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Minimum number of idle connections
+    ///
+    /// Defaults to `0`
+    pub fn min_idle(mut self, min_idle: u32) -> Self {
+        self.min_idle = min_idle;
+        self
+    }
+
+    /// Maximum number of pooled connections
+    ///
+    /// Defaults to `10`
+    pub fn max_size(mut self, max_size: u32) -> Self {
+        self.max_size = max_size;
+        self
+    }
+
+    /// Connection timeout
+    ///
+    /// Defaults to `30 seconds`
+    pub fn connection_timeout(mut self, connection_timeout: Duration) -> Self {
+        self.connection_timeout = connection_timeout;
+        self
+    }
+
+    /// Connection idle timeout
+    ///
+    /// Defaults to `60 seconds`
+    pub fn idle_timeout(mut self, idle_timeout: Duration) -> Self {
+        self.idle_timeout = idle_timeout;
+        self
+    }
+
+    pub(crate) fn build<C: ManageConnection>(&self, client: C) -> Pool<C> {
+        Pool::builder()
+            .min_idle(Some(self.min_idle))
+            .max_size(self.max_size)
+            .connection_timeout(self.connection_timeout)
+            .idle_timeout(Some(self.idle_timeout))
+            .build_unchecked(client)
+    }
+}
+
+impl Default for PoolConfig {
+    fn default() -> Self {
+        Self {
+            min_idle: 0,
+            max_size: 10,
+            connection_timeout: Duration::from_secs(30),
+            idle_timeout: Duration::from_secs(60),
+        }
+    }
+}
 
 impl ManageConnection for SmtpClient {
     type Connection = SmtpConnection;

src/transport/smtp/response.rs

@@ -32,7 +32,7 @@ pub enum Severity {
 }
 
 impl Display for Severity {
-    fn fmt(&self, f: &mut Formatter) -> Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
         write!(f, "{}", *self as u8)
     }
 }
@@ -56,7 +56,7 @@ pub enum Category {
 }
 
 impl Display for Category {
-    fn fmt(&self, f: &mut Formatter) -> Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
         write!(f, "{}", *self as u8)
     }
 }
@@ -88,7 +88,7 @@ pub enum Detail {
 }
 
 impl Display for Detail {
-    fn fmt(&self, f: &mut Formatter) -> Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
         write!(f, "{}", *self as u8)
     }
 }
@@ -106,7 +106,7 @@ pub struct Code {
 }
 
 impl Display for Code {
-    fn fmt(&self, f: &mut Formatter) -> Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
         write!(f, "{}{}{}", self.severity, self.category, self.detail)
     }
 }
@@ -151,10 +151,10 @@ impl Response {
 
     /// Tells if the response is positive
     pub fn is_positive(&self) -> bool {
-        match self.code.severity {
-            Severity::PositiveCompletion | Severity::PositiveIntermediate => true,
-            _ => false,
-        }
+        matches!(
+            self.code.severity,
+            Severity::PositiveCompletion | Severity::PositiveIntermediate
+        )
     }
 
     /// Tests code equality
@@ -238,7 +238,10 @@ pub(crate) fn parse_response(i: &str) -> IResult<&str, Response> {
 
     // Check that all codes are equal.
     if !lines.iter().all(|&(code, _, _)| code == last_code) {
-        return Err(nom::Err::Failure(("", nom::error::ErrorKind::Not)));
+        return Err(nom::Err::Failure(nom::error::Error::new(
+            "",
+            nom::error::ErrorKind::Not,
+        )));
     }
 
     // Extract text from lines, and append last line.

src/transport/smtp/transport.rs

@@ -3,13 +3,16 @@ use std::time::Duration;
 #[cfg(feature = "r2d2")]
 use r2d2::Pool;
 
+#[cfg(feature = "r2d2")]
+use super::PoolConfig;
 use super::{ClientId, Credentials, Error, Mechanism, Response, SmtpConnection, SmtpInfo};
 #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
 use super::{Tls, TlsParameters, SUBMISSIONS_PORT, SUBMISSION_PORT};
-use crate::{Envelope, Transport};
+use crate::{address::Envelope, Transport};
 
 #[allow(missing_debug_implementations)]
 #[derive(Clone)]
+/// Transport using the SMTP protocol
 pub struct SmtpTransport {
     #[cfg(feature = "r2d2")]
     inner: Pool<SmtpClient>,
@@ -38,7 +41,7 @@ impl Transport for SmtpTransport {
 }
 
 impl SmtpTransport {
-    /// Simple and secure transport, using TLS connections to comunicate with the SMTP server
+    /// Simple and secure transport, using TLS connections to communicate with the SMTP server
     ///
     /// The right option for most SMTP servers.
     ///
@@ -93,17 +96,27 @@ impl SmtpTransport {
     /// [`SmtpTransport::starttls_relay`](#method.starttls_relay) instead,
     /// if possible.
     pub fn builder_dangerous<T: Into<String>>(server: T) -> SmtpTransportBuilder {
-        let mut new = SmtpInfo::default();
-        new.server = server.into();
-        SmtpTransportBuilder { info: new }
+        let new = SmtpInfo {
+            server: server.into(),
+            ..Default::default()
+        };
+
+        SmtpTransportBuilder {
+            info: new,
+            #[cfg(feature = "r2d2")]
+            pool_config: PoolConfig::default(),
+        }
     }
 }
 
-/// Contains client configuration
+/// Contains client configuration.
+/// Instances of this struct can be created using functions of [`SmtpTransport`].
 #[allow(missing_debug_implementations)]
 #[derive(Clone)]
 pub struct SmtpTransportBuilder {
     info: SmtpInfo,
+    #[cfg(feature = "r2d2")]
+    pool_config: PoolConfig,
 }
 
 /// Builder for the SMTP `SmtpTransport`
@@ -145,27 +158,25 @@ impl SmtpTransportBuilder {
         self
     }
 
-    /// Build the client
-    fn build_client(self) -> SmtpClient {
-        SmtpClient { info: self.info }
+    /// Use a custom configuration for the connection pool
+    ///
+    /// Defaults can be found at [`PoolConfig`]
+    #[cfg(feature = "r2d2")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "r2d2")))]
+    pub fn pool_config(mut self, pool_config: PoolConfig) -> Self {
+        self.pool_config = pool_config;
+        self
     }
 
     /// Build the transport
     ///
     /// If the `r2d2` feature is enabled an `Arc` wrapped pool is be created.
-    /// Defaults:
-    ///
-    /// * 60 seconds idle timeout
-    /// * 30 minutes max connection lifetime
-    /// * max pool size of 10 connections
+    /// Defaults can be found at [`PoolConfig`]
     pub fn build(self) -> SmtpTransport {
-        let client = self.build_client();
+        let client = SmtpClient { info: self.info };
         SmtpTransport {
             #[cfg(feature = "r2d2")]
-            inner: Pool::builder()
-                .min_idle(Some(0))
-                .idle_timeout(Some(Duration::from_secs(60)))
-                .build_unchecked(client),
+            inner: self.pool_config.build(client),
             #[cfg(not(feature = "r2d2"))]
             inner: client,
         }
@@ -190,6 +201,7 @@ impl SmtpClient {
             _ => None,
         };
 
+        #[allow(unused_mut)]
         let mut conn = SmtpConnection::connect::<(&str, u16)>(
             (self.info.server.as_ref(), self.info.port),
             self.info.timeout,

src/transport/smtp/util.rs

@@ -8,7 +8,7 @@ use std::fmt::{Display, Formatter, Result as FmtResult};
 pub struct XText<'a>(pub &'a str);
 
 impl<'a> Display for XText<'a> {
-    fn fmt(&self, f: &mut Formatter) -> FmtResult {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         let mut rest = self.0;
         while let Some(idx) = rest.find(|c| c < '!' || c == '+' || c == '=') {
             let (start, end) = rest.split_at(idx);

src/transport/stub/mod.rs

@@ -7,27 +7,31 @@
 //! testing purposes.
 //!
 //! ```rust
-//! use lettre::{Message, Envelope, Transport, StubTransport};
+//! # #[cfg(feature = "builder")]
+//! # {
+//! use lettre::{transport::stub::StubTransport, Message, Transport};
 //!
+//! # use std::error::Error;
+//! # fn main() -> Result<(), Box<dyn 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())
+//!     .from("NoBody <nobody@domain.tld>".parse()?)
+//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
+//!     .to("Hei <hei@domain.tld>".parse()?)
 //!     .subject("Happy new year")
-//!     .body("Be happy!")
-//!     .unwrap();
+//!     .body(String::from("Be happy!"))?;
 //!
 //! let mut sender = StubTransport::new_ok();
 //! let result = sender.send(&email);
 //! assert!(result.is_ok());
+//! # Ok(())
+//! # }
+//! # }
 //! ```
 
-#[cfg(feature = "async-std1")]
-use crate::AsyncStd1Transport;
-#[cfg(feature = "tokio02")]
-use crate::Tokio02Transport;
-use crate::{Envelope, Transport};
-#[cfg(any(feature = "async-std1", feature = "tokio02"))]
+#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
+use crate::AsyncTransport;
+use crate::{address::Envelope, Transport};
+#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
 use async_trait::async_trait;
 use std::{error::Error as StdError, fmt};
 
@@ -49,7 +53,7 @@ pub struct StubTransport {
 }
 
 impl StubTransport {
-    /// Creates aResult new transport that always returns the given response
+    /// Creates a new transport that always returns the given Result
     pub fn new(response: Result<(), Error>) -> StubTransport {
         StubTransport { response }
     }
@@ -76,20 +80,9 @@ impl Transport for StubTransport {
     }
 }
 
-#[cfg(feature = "async-std1")]
+#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
 #[async_trait]
-impl AsyncStd1Transport for StubTransport {
-    type Ok = ();
-    type Error = Error;
-
-    async fn send_raw(&self, _envelope: &Envelope, _email: &[u8]) -> Result<Self::Ok, Self::Error> {
-        self.response
-    }
-}
-
-#[cfg(feature = "tokio02")]
-#[async_trait]
-impl Tokio02Transport for StubTransport {
+impl AsyncTransport for StubTransport {
     type Ok = ();
     type Error = Error;
 

testdata/email_with_png.eml

@@ -0,0 +1,233 @@
+Date: Tue, 15 Nov 1994 08:12:31 GMT
+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"
+
+--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1
+Content-Type: text/html; charset=utf8
+Content-Transfer-Encoding: 7bit
+
+<p><b>Hello</b>, <i>world</i>! <img src=cid:123></p>
+--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1
+Content-Type: image/png
+Content-Disposition: inline
+Content-ID: <123>
+Content-Transfer-Encoding: base64
+
+iVBORw0KGgoAAAANSUhEUgAAA+gAAAPoCAYAAABNo9TkAAAACXBIWXMAASdGAAEnRgHWSSfaAAAA
+GXRFWHRTb2Z0d2FyZQB3d3cuaW5rc2NhcGUub3Jnm+48GgAAIABJREFUeJzs3WmMlfXd//HvzLAO
+izAORCmKgKmKKQa1taUWl1C1cWm1rVvdSls01bbGpcsDTWOrMcabdNNiXdqkrSamMbY2hkTbOiyD
+0HFBiRSLE6WFKgoFFIRBztwP7M2//gEVnJnf95zzeiUmLjDziYlnztvrd12noaOjozsAAACAohpL
+DwAAAAAEOgAAAKQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQE
+OgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg
+0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACAB
+gQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJ
+CHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABI
+QKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABA
+AgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAA
+EhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAA
+kIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAA
+gAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAA
+ACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEA
+ACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4A
+AAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQA
+AABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKAD
+AABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgId
+AAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJ9Cs9ADL6wx/+EHfffXfpGQB7ZNiw
+YfGb3/ym9AwAYC8JdNiFN954I1atWlV6BsAeGT58eOkJAMAH4Ig7AAAAJCDQAQAAIAGBDgAAAAkI
+dAAAAEhAoAMAAEACAh0AAAASEOgAAACQgEAHAACABAQ6AAAAJCDQAQAAIAGBDgAAAAkIdAAAAEhA
+oAMAAEACAh0AAAASEOgAAACQgEAHAACABAQ6AAAAJCDQAQAAIAGBDgAAAAkIdAAAAEhAoAMAAEAC
+Ah0AAAASEOgAAACQgEAHAACABAQ6AAAAJCDQAQAAIAGBDgAAAAkIdAAAAEhAoAMAAEACAh0AAAAS
+EOgAAACQgEAHAACABAQ6AAAAJCDQAQAAIAGBDgAAAAkIdAAAAEhAoAMAAEACAh0AAAASEOgAAACQ
+gEAHAACABAQ6AAAAJCDQAQAAIAGBDgAAAAkIdAAAAEhAoAMAAEACAh0AAAASEOgAAACQgEAHAACA
+BAQ6AAAAJCDQAQAAIAGBDgAAAAkIdAAAAEhAoAMAAEACAh0AAAASEOgAAACQgEAHAACABAQ6AAAA
+JCDQAQAAIAGBDgAAAAkIdAAAAEhAoAMAAEACAh0AAAASEOgAAACQgEAHAACABAQ6AAAAJCDQAQAA
+IAGBDgAAAAkIdAAAAEhAoAMAAEACAh0AAAASEOgAAACQgEAHAACABAQ6AAAAJCDQAQAAIAGBDgAA
+AAkIdAAAAEhAoAMAAEACAh0AAAASEOgAAACQgEAHAACABAQ6AAAAJCDQAQAAIAGBDgAAAAkIdAAA
+AEhAoAMAAEACAh0AAAASEOgAAACQgEAHAACABAQ6AAAAJCDQAQAAIAGBDgAAAAkIdAAAAEhAoAMA
+AEACAh0AAAASEOgAAACQgEAHAACABAQ6AAAAJCDQAQAAIAGBDgAAAAkIdAAAAEhAoAMAAEACAh0A
+AAASEOgAAACQgEAHAACABAQ6AAAAJCDQAQAAIAGBDgAAAAkIdAAAAEhAoAMAAEACAh0AAAASEOgA
+AACQgEAHAACABAQ6AAAAJCDQAQAAIIF+pQdARieeeGIcfPDBpWdQJ55//vn40Y9+VHoGAACFCXTY
+hf322y/222+/0jOoE01NTaUnAACQgCPuAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQA
+AABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKAD
+AABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgId
+AAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDo
+AAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBA
+BwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQE
+OgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg
+0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACAB
+gQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJ
+CHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABI
+QKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABA
+AgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAA
+EhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAA
+kIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAA
+gAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAA
+ACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEA
+ACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4A
+AAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQA
+AABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKAD
+AABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgId
+AAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDo
+AAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBA
+BwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQE
+OgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg
+0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACAB
+gQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJ
+CHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABI
+QKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABA
+AgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAA
+EhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAA
+kIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAA
+gAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAA
+ACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEA
+ACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4A
+AAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQA
+AABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKAD
+AABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgId
+AAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDo
+AAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBA
+BwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQE
+OgAAACQg0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg
+0AEAACABgQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACAB
+gQ4AAAAJCHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJ
+CHQAAABIQKADAABAAgIdAAAAEhDoAAAAkIBABwAAgAQEOgAAACQg0AEAACABgQ4AAAAJCHQAAABI
+QKADFNbY6KUYAACBDlBcU1NT6QkAACQg0AEK69evX+kJAAAkINABCnMFHQCACIEOUJxABwAgQqAD
+FOeIOwAAEQIdoDhPcaenbN++vfQEAOAD8K4QoDBX0Okpb731VukJAMAHINABChPo9BSBDgDVTaAD
+FOYhcfSU7du3R3d3d+kZAMBeEugAhQl0epL70AGgegl0gML69+9fegI1pKurq/QEAGAvCXSAwgYP
+HhwNDQ2lZ1AjXn/99dITAIC9JNABCmtsbIyBAweWnkGNEOgAUL0EOkACzc3NpSdQIwQ6AFQvgQ6Q
+gECnpwh0AKheAh0ggSFDhpSeQI144403Sk8AAPaSQAdIwBV0esprr71WegIAsJcEOkACAp2esmbN
+mtITAIC9JNABEnDEnZ4i0AGgegl0gAQGDx5cegI1QqADQPUS6AAJuIJOTxHoAFC9BDpAAgKdnvLa
+a6/F1q1bS88AAPaCQAdIYPjw4aUnUCMqlUqsXLmy9AwAYC8IdIAEWlpaSk+ghrz44oulJwAAe0Gg
+AyQwcuTI0hOoIQIdAKqTQAdIQKDTkwQ6AFQngQ6QgCPu9KTly5eXngAA7AWBDpDAyJEjo7HRSzI9
+46WXXoo33nij9AwAYA95NwiQQGNjoye502O6u7tdRQeAKiTQAZJwzJ2e9Nxzz5WeAADsIYEOkMSI
+ESNKT6CGLF26tPQEAGAPCXSAJFxBpyd1dHREpVIpPQMA2AMCHSAJgU5P2rBhQ6xYsaL0DABgDwh0
+gCRaW1tLT6DGdHR0lJ4AAOwBgQ6QxJgxY0pPoMYsXry49AQAYA8IdIAk9t9//9ITqDEdHR3x5ptv
+lp4BALxPAh0gCYFOT9uyZUssWrSo9AwA4H0S6ABJtLa2Rv/+/UvPoMb85S9/KT0BAHifBDpAEo2N
+jTF69OjSM6gxc+fOjW3btpWeAQC8DwIdIBEPiqOnvf766x4WBwBVQqADJOI+dHrDQw89VHoCAPA+
+CHSARPbbb7/SE6hBbW1tsX79+tIzAID3INABEnEFnd6wbdu2mDNnTukZAMB7EOgAibgHnd7ywAMP
+RHd3d+kZAMC7EOgAiRx44IGlJ1CjOjs7Y+HChaVnAADvQqADJDJq1KgYOnRo6RnUqHvvvbf0BADg
+XQh0gGQOOuig0hOoUY8//ng8//zzpWcAALsh0AGSmTBhQukJ1LBf/epXpScAALsh0AGScQWd3vTI
+I4+4ig4ASQl0gGTGjx9fegI1rLu7O2bPnl16BgCwCwIdIBlH3Oltc+fOjWeffbb0DADg/yPQAZLZ
+f//9Y+DAgaVnUONuueWWqFQqpWcAAP9FoAMk09jYGOPGjSs9gxq3bNmyePDBB0vPAAD+i0AHSMiD
+4ugLP/vZz2L9+vWlZwAA/yHQARI6+OCDS0+gDmzcuDFmzZpVegYA8B8CHSChQw89tPQE6sTDDz8c
+jz76aOkZAEAIdICUJk2aVHoCdeTmm2+OtWvXlp4BAHVPoAMkNGLEiBgzZkzpGdSJ9evXxw033OCp
+7gBQmEAHSOqwww4rPYE6smDBgrjnnntKzwCAuibQAZIS6PS1X/ziF9He3l56BgDULYEOkJT70Olr
+lUolrrvuuli5cmXpKQBQlwQ6QFKTJk2KhoaG0jOoMxs2bIgrrrgi1q1bV3oKANQdgQ6Q1NChQ+OA
+Aw4oPYM6tHr16rjyyivjzTffLD0FAOqKQAdIzOehU8pzzz0X3/72t6Orq6v0FACoGwIdILHDDz+8
+9ATq2MKFC+Oaa64R6QDQRwQ6QGJTpkwpPYE6197eHtdee61IB4A+INABEjvkkENiyJAhpWdQ5xYs
+WBCXXnpprF+/vvQUAKhpAh0gsaampjjiiCNKz4B49tlnY+bMmfHyyy+XngIANUugAyR31FFHlZ4A
+ERHR2dkZM2bMiKVLl5aeAgA1SaADJHfkkUeWngA7rFmzJmbOnBkPPPBA6Skk0dXV5RkFAD1EoAMk
+d9hhh8XgwYNLz4Adurq64qabboof/OAHPiu9jj333HNxyy23xCmnnBJz584tPQegJgh0gOT69esX
+kydPLj0DdvL73/8+zjnnnFiyZEnpKfSRtWvXxn333Rfnn39+XHTRRXH//ffHxo0bBTpAD+lXegAA
+7+2oo46KRYsWlZ4BO1m9enVceuml8ZWvfCUuueSS6N+/f+lJ9LCurq6YP39+PPTQQ9He3h7bt2/f
+6dfMnz8/tm/fHk1NTQUWAtQOgQ5QBdyHTmZvvfVW3HHHHfHII4/E9773vZgyZUrpSfSAZcuWxR//
++MeYM2dObNiw4V1/7caNG2PJkiVeqwA+IIEOUAUmTZoUgwYNii1btpSeArvV2dkZM2fOjNNPPz0u
+v/zy2HfffUtPYg8tW7Ys/vznP8ef/vSnWLly5R793ra2NoEO8AE1dHR0dJceAcB7u+qqq9znSdUY
+PHhwnH322TFjxowYMmRI6Tm8i87Oznj00Udjzpw5exzl/23s2LHx4IMP9uAygPoj0AGqxAMPPBA3
+3XRT6RmwR1pbW+Piiy+OM888MwYNGlR6DhFRqVTimWee2XGl/JVXXumxr33//ffHhAkTeuzrAdQb
+gQ5QJdasWROnnnpqdHd72ab6tLS0xAUXXBBf+MIXorm5ufScurN58+b461//GgsXLoy2trZ49dVX
+e+X7XHHFFXHJJZf0ytcGqAcCHaCKnH/++fH888+XngF7rbm5OU455ZQ499xzXWntRZVKJZYvXx6L
+Fy+ORYsWxVNPPRXbtm3r9e87efLkuOeee3r9+wDUKoEOUEVuv/12b36pCQ0NDXHMMcfE6aefHscf
+f3wMHDiw9KSq9+qrr8bjjz8eCxcujMWLF8f69ev7fENjY2PMmTMnWlpa+vx7A9QCgQ5QRZ555pmY
+MWNG6RnQo4YOHRrTp0+Pk08+OY466qhobGwsPSm97u7ueOmll+LZZ5+NZ555JpYsWRKdnZ2lZ0VE
+xHXXXRef/exnS88AqEoCHaCKVCqVOOmkk4pcGYO+MGLEiJg2bVqccMIJcfTRR8fgwYNLT0rhzTff
+jOeeey6WLFmyI8rf67PJS5k2bVrMmjWr9AyAqiTQAarM9ddfHw8//HDpGdDrBgwYEJMnT46Pf/zj
+cfTRR8ehhx4a/fr1Kz2r161bty5WrFgRnZ2d8cILL8SyZcvi73//e2zfvr30tPdl0KBB8eijj3pq
+P8BeqP2fcgA15thjjxXo1IWurq7o6OiIjo6OiHg7/CZNmhRHHHFEHHLIITFx4sQ44IADqjbaN27c
+GC+++GKsWLEiXnjhhejs7IwVK1bEv//979LTPpAtW7bE4sWLY9q0aaWnAFSd6vyJBlDHpk6dGgMG
+DIiurq7SU6BPbdmyJZ588sl48sknd/y9/v37x7hx42LChAkxceLEGD9+fIwfPz5Gjx4dQ4YMKba1
+UqnE2rVr41//+le8/PLL8fLLL+/489WrV8fLL78cmzZtKravt7W1tQl0gL0g0AGqzNChQ2Pq1Knx
+2GOPlZ4CxW3bti1WrFgRK1as2OmfDRw4MFpbW6O1tTX23XffaG1tjZaWlmhpaYmmpqYYMmRINDQ0
+xLBhwyLi7f+2Ghoa3vG1t2zZEhERW7duja1bt0bE2/eDb9q0KTZu3Ljjjw0bNsTrr78eGzZs2PHX
+lUqlD/4N5DRv3ryoVCoe+AewhwQ6QBU66aSTBDq8h61bt8aqVati1apVpafUnXXr1sXSpUtj8uTJ
+pacAVBX/WxOgCk2bNi2am5tLzwDYrXnz5pWeAFB1BDpAFRo0aFAce+yxpWcA7FZbW1vpCQBVR6AD
+VKmTTjqp9ASA3ers7IyVK1eWngFQVQQ6QJWaOnXqjodbAWTkmDvAnhHoAFVqwIABcfzxx5eeAbBb
+c+fOLT0BoKoIdIAq9ulPf7r0BIDdeuqpp2LDhg2lZwBUDYEOUMU+9rGPRUtLS+kZALtUqVRiwYIF
+pWcAVA2BDlDF+vXrF6eddlrpGQC75Zg7wPsn0AGq3FlnnRUNDQ2lZwDsUnt7e3R1dZWeAVAVBDpA
+lRs7dmwcddRRpWcA7NLmzZvjiSeeKD0DoCoIdIAacOaZZ5aeALBbPm4N4P0R6AA14MQTT4yRI0eW
+ngGwS4899lh0d3eXngGQnkAHqAH9+/ePU089tfQMgF1as2ZNLF++vPQMgPQEOkCNOPPMMz0sDkjL
+09wB3ptAB6gR48aNiylTppSeAbBLAh3gvQl0gBry+c9/vvQEgF1avnx5vPLKK6VnAKQm0AFqyPTp
+02P//fcvPQNgJ93d3a6iA7wHgQ5QQ5qamuK8884rPQNglwQ6wLsT6AA15nOf+1wMGzas9AyAnXR0
+dMSmTZtKzwBIS6AD1Jjm5uY466yzSs8A2Mm2bdti4cKFpWcApCXQAWrQl770pRgwYEDpGQA7ccwd
+YPcEOkANamlpiVNOOaX0DICdzJ8/P7Zv3156BkBKAh2gRl100UXR2OhlHshl48aN8fTTT5eeAZCS
+d24ANeqggw6KT3ziE6VnAOzEMXeAXRPoADVsxowZpScA7KStra30BICUBDpADTviiCNi6tSppWcA
+vMM///nP6OzsLD0DIB2BDlDjvv71r0dDQ0PpGQDv4Co6wM4EOkCNO/TQQ+OEE04oPQPgHebNm1d6
+AkA6Ah2gDlx++eXR1NRUegbADkuXLo21a9eWngGQikAHqAPjxo2Lk08+ufQMgB0qlUrMnz+/9AyA
+VAQ6QJ247LLLon///qVnAOzgPnSAdxLoAHVizJgxcfrpp5eeAbDDokWLYsuWLaVnAKQh0AHqyFe/
++tUYPHhw6RkAERGxdevWWLx4cekZAGkIdIA6Mnr06Pjyl79cegbADo65A/w/Ah2gzlx44YVx4IEH
+lp4BEBFvf9xapVIpPQMgBYEOUGf69+8f3/rWt0rPAIiIiHXr1sXSpUtLzwBIQaAD1KHjjjsupk6d
+WnoGQES8fRUdAIEOULeuvfbaGDBgQOkZAO5DB/gPgQ5Qpw444IA455xzSs8AiM7Ozli5cmXpGQDF
+CXSAOva1r30tRo0aVXoGgGPuACHQAepac3NzfPOb3yw9AyDmzp1begJAcQIdoM595jOfiRNOOKH0
+DKDOPfXUU7Fhw4bSMwCKEugAxHe+850YPnwtwJqJAAAO10lEQVR46RlAHatUKrFgwYLSMwCKEugA
+RGtra1x11VWlZwB1zjF3oN4JdAAiIuK0006L4447rvQMoI61t7dHV1dX6RkAxQh0AHb47ne/66g7
+UMzmzZvjiSeeKD0DoBiBDsAOo0aNiiuvvLL0DKCOOeYO1DOBDsA7nHHGGTF16tTSM4A61dbWFt3d
+3aVnABQh0AHYyfe///3Yd999S88A6tCaNWti+fLlpWcAFCHQAdhJS0tL/PCHP4zGRj8mgL7nmDtQ
+r7zzAmCXPvrRj8bFF19cegZQhwQ6UK8EOgC7ddlll8WUKVNKzwDqzN/+9rdYvXp16RkAfU6gA7Bb
+TU1NceONN8aIESNKTwHqzPz580tPAOhzAh2AdzV69Oi44YYboqGhofQUoI7Mmzev9ASAPifQAXhP
+U6dOjQsuuKD0DKCOdHR0xKZNm0rPAOhTAh2A9+Xyyy+PI488svQMoE5s27YtFi5cWHoGQJ8S6AC8
+L/369Ytbb701DjzwwNJTgDrhae5AvRHoALxvw4cPj1mzZsWwYcNKTwHqwPz582P79u2lZwD0GYEO
+wB456KCD4uabb46mpqbSU4Aat3Hjxnj66adLzwDoMwIdgD12zDHHxNVXX116BlAH2traSk8A6DMC
+HYC9cvbZZ8cXv/jF0jOAGifQgXoi0AHYa9dee2188pOfLD0DqGGrVq2Kzs7O0jMA+oRAB2CvNTY2
+xo033hgf/vCHS08Bapir6EC9EOgAfCBDhw6N2267LcaPH196ClCj5s2bV3oCQJ8Q6AB8YCNHjozb
+brstxowZU3oKUIOWLl0aa9euLT0DoNcJdAB6xOjRo+P222+P1tbW0lOAGlOpVFxFB+qCQAegx4wd
+OzZuu+222GeffUpPAWrM3LlzS08A6HUCHYAeNXHixPjJT34Szc3NpacANWTRokWxZcuW0jMAepVA
+B6DHHX744TFr1qwYNGhQ6SlAjdi6dWssXry49AyAXiXQAegVRx99dPz0pz+NIUOGlJ4C1AgftwbU
+OoEOQK+ZMmVKzJ49O0aMGFF6ClAD5s2bF5VKpfQMgF4j0AHoVYcddljceeedMXr06NJTgCq3bt26
+WLp0aekZAL1GoAPQ68aPHx933XVXjB07tvQUoMr5uDWglgl0APrEmDFj4q677oqJEyeWngJUMfeh
+A7VMoAPQZ1pbW+PnP/95HHLIIaWnAFWqs7Mz/vGPf5SeAdArBDoAfaqlpSXuvPPOOO6440pPAarU
+3LlzS08A6BUCHYA+19zcHLfeemvMnDmz9BSgCgl0oFYJdACKaGhoiJkzZ8b1118f/fv3Lz0HqCJP
+PfVUrF+/vvQMgB4n0AEo6owzzojZs2fHyJEjS08BqkSlUon29vbSMwB6nEAHoLgjjjgifvnLX8b4
+8eNLTwGqhGPuQC0S6ACkMHbs2Ljnnnti6tSppacAVaC9vT26urpKzwDoUQIdgDSGDRsWP/7xj+Pq
+q6+Ofv36lZ4DJLZ58+Z44oknSs8A6FECHYBUGhoa4rzzzou77747xowZU3oOkJhj7kCtEegApHT4
+4YfHr3/96/jUpz5VegqQVFtbW3R3d5eeAdBjBDoAae2zzz4xa9asuPrqq30UG7CTNWvWxPLly0vP
+AOgxAh2A1P77yPuHPvSh0nOAZBxzB2qJQAegKkyaNCnuvffeOPfcc6Ox0Y8v4G1tbW2lJwD0GO9w
+AKgaQ4YMiWuuuSbuuOOOOPDAA0vPARJYvnx5rF69uvQMgB4h0AGoOlOmTIn77rsvLr74YlfTgZg/
+f37pCQA9wrsaAKrSwIED4xvf+EbcddddcdBBB5WeAxQ0b9680hMAeoRAB6CqTZ48OX7729/GhRde
+6Go61KmOjo7YvHlz6RkAH1hDR0eHD48EoCa8+OKLMWvWrGhvby89BegDEyZMiOnTp8f06dNjwoQJ
+pecAfGACHYCaM3fu3Pif//mfWLVqVekpQA9qbGyMj3zkIzFt2rQ44YQTPCwSqDkCHYCatG3btvjd
+734Xs2fPjk2bNpWeA+yl/4vy/7tSPmrUqNKTAHqNQAegpr322mvxi1/8b3t391J1usZx+M6VQrqW
+tbSyLEgtCUtIijRNI6K/sKPaMOcdVVBBUVTUQVRSIpLlQfRGlNILaEYWug82IxMje2aY6nfbui74
+4WKh+D3TDz74/CfOnTsXi4uLRc8B/oaGhoYYGBiIkZGROHr0aLS0tBQ9CeCnEOgA1ISJiYk4ceJE
+3L9/v+gpwAqamppieHg4jh07FkNDQ7Fu3bqiJwH8dAIdgJoyNjYWp06dinv37hU9BWpec3NzDA8P
+x/Hjx+PQoUPR0NBQ9CSAQgl0AGrS2NhYnDx5MkZHR4ueAjVl27ZtMTIyEkeOHIn9+/fH2rVri54E
+kIZAB6CmCXX4serq6mL37t0xMjLiOjSAvyDQASAibt++Hb/99luMjY0VPQVWvXK5HENDQ3HkyJEY
+GhqK5ubmoicBrAoCHQD+4NGjR3HmzJm4cOFCLCwsFD0HVo329vY4dOhQDA8Px+DgYNTX1xc9CWDV
+EegAsIJ3797F+fPn4/Tp0zEzM1P0HEjnj0fXR0ZGoqenp+hJAKueQAeA/2NhYSEuXboUp0+fjqmp
+qaLnQKE2bNgQ/f39MTQ0FIcPH45qtVr0JIBfikAHgL9pdHQ0zpw5Ezdu3HD8nZpQKpWit7c3BgcH
+Y3BwMHp6eqKurq7oWQC/LIEOAP/Q7OxsXLlyJS5evBjj4+OxtORHKb+O9vb2GBgYiMHBwTh48GBU
+KpWiJwHUDIEOAP/C69ev4/Lly3H27Nl4+fJl0XPgH6tWq3HgwIHo7++Pvr4+16ABFEigA8B3sLi4
+GA8ePIgLFy7E9evXY25uruhJsKJyuRz79++PgwcPRn9/f3R1dcWaNWuKngVACHQA+O4WFxdjfHw8
+rl69GteuXYvp6emiJ1HDWlpaYu/evdHX1xf79u2L3t7eWLt2bdGzAFiBQAeAH+zJkydx9erVuHXr
+VkxOThY9h1/cxo0bo6+vb/nIemdnp7+QA6wSAh0AfqLnz5/HjRs34ubNmzExMRFfv34tehKrWKVS
+ib1790Zvb+/yR1efAaxeAh0ACjI/Px9jY2MxOjoao6Oj8ejRo1hcXCx6FknV19fHrl27vonxHTt2
++Os4wC9EoANAEvPz8zExMRF37tyJu3fvxuPHjwV7jSqXy7Fz587o6emJrq6u6Orqij179kRDQ0PR
+0wD4gQQ6ACT1/v37GB8fj4cPH8bk5GQ8fPgwPnz4UPQsvqOGhobo6OiIjo6O2LlzZ3R3d0d3d3ds
+3bq16GkAFECgA8Aq8urVq+VYn5ycjMnJyZidnS16Fn+hUqnEjh07oqurKzo6OqKzszM6Ozujvb09
+6urqip4HQBICHQBWsaWlpXjx4kVMTU3F8+fP4+nTp/H06dN49uxZfPz4seh5NaNUKkVbW1ts3749
+tm3b9s2zffv2aG5uLnoiAKuAQAeAX9TMzEw8e/Zs+fk93Kenp+PLly9Fz1s1SqVStLa2xpYtW2Lj
+xo3R1tYWmzdvjk2bNi2/bmtrc7c4AP+aQAeAGvT27duYmZmJ6enpmJ6ejpmZmXjz5s03r+fn54ue
++UPU19dHpVKJDRs2LD/VajWq1WqsX79++b3W1taoVqvR2trqGDoAP4VABwBWND8/H7Ozs988c3Nz
+MTc3t+L7S0tLMTc3t/z1s7OzsbT0v18zPn36tHzn++fPn+PLly9RLpdX/L7lcvlPV4f9fkS8Uqks
+f05dXV00NTVFqVSKxsbGKJVK0dTU9KenUqlEuVyOpqamKJfL/hM6AGk5iwUArKixsTEaGxujra2t
+6CkAUBOc1wIAAIAEBDoAAAAkINABAAAgAYEOAAAACQh0AAAASECgAwAAQAICHQAAABIQ6AAAAJCA
+QAcAAIAEBDoAAAAkINABAAAgAYEOAAAACQh0AAAASECgAwAAQAICHQAAABIQ6AAAAJCAQAcAAIAE
+BDoAAAAkINABAAAgAYEOAAAACQh0AAAASECgAwAAQAICHQAAABIQ6AAAAJCAQAcAAIAEBDoAAAAk
+INABAAAgAYEOAAAACQh0AAAASECgAwAAQAICHQAAABIQ6AAAAJCAQAcAAIAEBDoAAAAkINABAAAg
+AYEOAAAACQh0AAAASECgAwAAQAICHQAAABIQ6AAAAJCAQAcAAIAEBDoAAAAkINABAAAgAYEOAAAA
+CQh0AAAASECgAwAAQAICHQAAABIQ6AAAAJCAQAcAAIAEBDoAAAAkINABAAAgAYEOAAAACQh0AAAA
+SECgAwAAQAICHQAAABIQ6AAAAJCAQAcAAIAEBDoAAAAkINABAAAgAYEOAAAACQh0AAAASECgAwAA
+QAICHQAAABIQ6AAAAJCAQAcAAIAEBDoAAAAkINABAAAgAYEOAAAACQh0AAAASECgAwAAQAICHQAA
+ABIQ6AAAAJCAQAcAAIAEBDoAAAAkINABAAAgAYEOAAAACQh0AAAASECgAwAAQAICHQAAABIQ6AAA
+AJCAQAcAAIAEBDoAAAAkINABAAAgAYEOAAAACQh0AAAASECgAwAAQAICHQAAABIQ6AAAAJCAQAcA
+AIAEBDoAAAAkINABAAAgAYEOAAAACQh0AAAASECgAwAAQAICHQAAABIQ6AAAAJCAQAcAAIAEBDoA
+AAAkINABAAAgAYEOAAAACQh0AAAASECgAwAAQAICHQAAABIQ6AAAAJCAQAcAAIAEBDoAAAAkINAB
+AAAgAYEOAAAACQh0AAAASECgAwAAQAICHQAAABIQ6AAAAJCAQAcAAIAEBDoAAAAkINABAAAgAYEO
+AAAACQh0AAAASECgAwAAQAICHQAAABIQ6AAAAJCAQAcAAIAEBDoAAAAkINABAAAgAYEOAAAACQh0
+AAAASECgAwAAQAICHQAAABIQ6AAAAJCAQAcAAIAEBDoAAAAkINABAAAgAYEOAAAACQh0AAAASECg
+AwAAQAICHQAAABIQ6AAAAJCAQAcAAIAEBDoAAAAkINABAAAgAYEOAAAACQh0AAAASECgAwAAQAIC
+HQAAABIQ6AAAAJDAfwHNjj3TR6+CggAAAABJRU5ErkJggg==
+--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1--

tests/transport_file.rs

@@ -1,11 +1,10 @@
 #[cfg(test)]
-#[cfg(feature = "file-transport")]
+#[cfg(all(feature = "file-transport", feature = "builder"))]
 mod test {
     use lettre::{transport::file::FileTransport, Message};
     use std::{
         env::temp_dir,
-        fs::{remove_file, File},
-        io::Read,
+        fs::{read_to_string, remove_file},
     };
 
     #[cfg(feature = "tokio02")]
@@ -21,78 +20,153 @@ mod test {
             .to("Hei <hei@domain.tld>".parse().unwrap())
             .subject("Happy new year")
             .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
-            .body("Be happy!")
+            .body(String::from("Be happy!"))
             .unwrap();
 
         let result = sender.send(&email);
         let id = result.unwrap();
 
-        let file = temp_dir().join(format!("{}.json", id));
-        let mut f = File::open(file.clone()).unwrap();
-        let mut buffer = String::new();
-        let _ = f.read_to_string(&mut buffer);
+        let eml_file = temp_dir().join(format!("{}.eml", id));
+        let eml = read_to_string(&eml_file).unwrap();
 
         assert_eq!(
-            buffer,
-            "{\"envelope\":{\"forward_path\":[\"hei@domain.tld\"],\"reverse_path\":\"nobody@domain.tld\"},\"raw_message\":null,\"message\":\"From: NoBody <nobody@domain.tld>\\r\\nReply-To: Yuin <yuin@domain.tld>\\r\\nTo: Hei <hei@domain.tld>\\r\\nSubject: Happy new year\\r\\nDate: Tue, 15 Nov 1994 08:12:31 GMT\\r\\n\\r\\nBe happy!\"}");
-        remove_file(file).unwrap();
+            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(feature = "async-std1")]
-    #[async_attributes::test]
-    async fn file_transport_asyncstd1() {
-        use lettre::AsyncStd1Transport;
-
-        let sender = FileTransport::new(temp_dir());
+    #[test]
+    #[cfg(feature = "file-transport-envelope")]
+    fn file_transport_with_envelope() {
+        use lettre::Transport;
+        let sender = FileTransport::with_envelope(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("Be happy!")
+            .body(String::from("Be happy!"))
+            .unwrap();
+
+        let result = sender.send(&email);
+        let id = result.unwrap();
+
+        let eml_file = temp_dir().join(format!("{}.eml", id));
+        let eml = read_to_string(&eml_file).unwrap();
+
+        let json_file = temp_dir().join(format!("{}.json", id));
+        let json = read_to_string(&json_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!"
+            )
+        );
+
+        assert_eq!(
+            json,
+            "{\"forward_path\":[\"hei@domain.tld\"],\"reverse_path\":\"nobody@domain.tld\"}"
+        );
+
+        let (e, m) = sender.read(&id).unwrap();
+
+        assert_eq!(&e, email.envelope());
+        assert_eq!(m, email.formatted());
+
+        remove_file(eml_file).unwrap();
+        remove_file(json_file).unwrap();
+    }
+
+    #[cfg(feature = "async-std1")]
+    #[async_std::test]
+    async fn file_transport_asyncstd1() {
+        use lettre::{AsyncFileTransport, AsyncStd1Executor, AsyncTransport};
+
+        let sender = AsyncFileTransport::<AsyncStd1Executor>::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 file = temp_dir().join(format!("{}.json", id));
-        let mut f = File::open(file.clone()).unwrap();
-        let mut buffer = String::new();
-        let _ = f.read_to_string(&mut buffer);
+        let eml_file = temp_dir().join(format!("{}.eml", id));
+        let eml = read_to_string(&eml_file).unwrap();
 
         assert_eq!(
-            buffer,
-            "{\"envelope\":{\"forward_path\":[\"hei@domain.tld\"],\"reverse_path\":\"nobody@domain.tld\"},\"raw_message\":null,\"message\":\"From: NoBody <nobody@domain.tld>\\r\\nReply-To: Yuin <yuin@domain.tld>\\r\\nTo: Hei <hei@domain.tld>\\r\\nSubject: Happy new year\\r\\nDate: Tue, 15 Nov 1994 08:12:31 GMT\\r\\n\\r\\nBe happy!\"}");
-        remove_file(file).unwrap();
+            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(feature = "tokio02")]
     #[tokio::test]
     async fn file_transport_tokio02() {
-        use lettre::Tokio02Transport;
+        use lettre::{AsyncFileTransport, AsyncTransport, Tokio02Executor};
 
-        let sender = FileTransport::new(temp_dir());
+        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("Be happy!")
+            .body(String::from("Be happy!"))
             .unwrap();
 
         let result = sender.send(email).await;
         let id = result.unwrap();
 
-        let file = temp_dir().join(format!("{}.json", id));
-        let mut f = File::open(file.clone()).unwrap();
-        let mut buffer = String::new();
-        let _ = f.read_to_string(&mut buffer);
+        let eml_file = temp_dir().join(format!("{}.eml", id));
+        let eml = read_to_string(&eml_file).unwrap();
 
         assert_eq!(
-            buffer,
-            "{\"envelope\":{\"forward_path\":[\"hei@domain.tld\"],\"reverse_path\":\"nobody@domain.tld\"},\"raw_message\":null,\"message\":\"From: NoBody <nobody@domain.tld>\\r\\nReply-To: Yuin <yuin@domain.tld>\\r\\nTo: Hei <hei@domain.tld>\\r\\nSubject: Happy new year\\r\\nDate: Tue, 15 Nov 1994 08:12:31 GMT\\r\\n\\r\\nBe happy!\"}");
-        remove_file(file).unwrap();
+            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();
     }
 }

tests/transport_sendmail.rs

@@ -1,5 +1,5 @@
 #[cfg(test)]
-#[cfg(feature = "sendmail-transport")]
+#[cfg(all(feature = "sendmail-transport", feature = "builder"))]
 mod test {
     use lettre::{transport::sendmail::SendmailTransport, Message};
 
@@ -15,7 +15,7 @@ mod test {
             .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 result = sender.send(&email);
@@ -24,40 +24,42 @@ mod test {
     }
 
     #[cfg(feature = "async-std1")]
-    #[async_attributes::test]
+    #[async_std::test]
     async fn sendmail_transport_asyncstd1() {
-        use lettre::AsyncStd1Transport;
+        use lettre::{AsyncSendmailTransport, AsyncStd1Executor, AsyncTransport};
 
-        let sender = SendmailTransport::new();
+        let sender = AsyncSendmailTransport::<AsyncStd1Executor>::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("Be happy!")
+            .body(String::from("Be happy!"))
             .unwrap();
 
         let result = sender.send(email).await;
+        println!("{:?}", result);
         assert!(result.is_ok());
     }
 
     #[cfg(feature = "tokio02")]
     #[tokio::test]
     async fn sendmail_transport_tokio02() {
-        use lettre::Tokio02Transport;
+        use lettre::{AsyncSendmailTransport, Tokio02Executor, Tokio02Transport};
 
-        let sender = SendmailTransport::new();
+        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("Be happy!")
+            .body(String::from("Be happy!"))
             .unwrap();
 
         let result = sender.send(email).await;
+        println!("{:?}", result);
         assert!(result.is_ok());
     }
 }

tests/transport_smtp.rs

@@ -1,5 +1,5 @@
 #[cfg(test)]
-#[cfg(feature = "smtp-transport")]
+#[cfg(all(feature = "smtp-transport", feature = "builder"))]
 mod test {
     use lettre::{Message, SmtpTransport, Transport};
 
@@ -10,7 +10,7 @@ mod test {
             .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();
         SmtpTransport::builder_dangerous("127.0.0.1")
             .port(2525)

tests/transport_smtp_pool.rs

@@ -1,6 +1,7 @@
 #[cfg(all(test, feature = "smtp-transport", feature = "r2d2"))]
 mod test {
-    use lettre::{Envelope, SmtpTransport, Transport};
+    use lettre::{address::Envelope, SmtpTransport, Transport};
+
     use std::{sync::mpsc, thread};
 
     fn envelope() -> Envelope {

tests/transport_stub.rs

@@ -1,61 +1,65 @@
-use lettre::{transport::stub::StubTransport, Message};
+#[cfg(test)]
+#[cfg(feature = "builder")]
+mod test {
+    use lettre::{transport::stub::StubTransport, Message};
 
-#[cfg(feature = "tokio02")]
-use tokio02_crate as tokio;
+    #[cfg(feature = "tokio02")]
+    use tokio02_crate as tokio;
 
-#[test]
-fn stub_transport() {
-    use lettre::Transport;
-    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")
-        .body("Be happy!")
-        .unwrap();
+    #[test]
+    fn stub_transport() {
+        use lettre::Transport;
+        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")
+            .body(String::from("Be happy!"))
+            .unwrap();
 
-    sender_ok.send(&email).unwrap();
-    sender_ko.send(&email).unwrap_err();
-}
-
-#[cfg(feature = "async-std1")]
-#[async_attributes::test]
-async fn stub_transport_asyncstd1() {
-    use lettre::AsyncStd1Transport;
-
-    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("Be happy!")
-        .unwrap();
-
-    sender_ok.send(email.clone()).await.unwrap();
-    sender_ko.send(email).await.unwrap_err();
-}
-
-#[cfg(feature = "tokio02")]
-#[tokio::test]
-async fn stub_transport_tokio02() {
-    use lettre::Tokio02Transport;
-
-    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("Be happy!")
-        .unwrap();
-
-    sender_ok.send(email.clone()).await.unwrap();
-    sender_ko.send(email).await.unwrap_err();
+        sender_ok.send(&email).unwrap();
+        sender_ko.send(&email).unwrap_err();
+    }
+
+    #[cfg(feature = "async-std1")]
+    #[async_std::test]
+    async fn stub_transport_asyncstd1() {
+        use lettre::AsyncStd1Transport;
+
+        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(feature = "tokio02")]
+    #[tokio::test]
+    async fn stub_transport_tokio02() {
+        use lettre::Tokio02Transport;
+
+        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();
+    }
 }