chore(all): Prepare 0.10.0-alpha.2 release

.github/workflows/audit.yml

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

.github/workflows/test.yml

@@ -1,127 +1,104 @@
-name: CI
+name: Continuous integration
 
-on:
-  pull_request:
-  push:
-    branches:
-      - master
-
-env:
-  RUST_BACKTRACE: full
+on: [push, pull_request]
 
 jobs:
-  rustfmt:
-    name: rustfmt / 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 rustfmt
-
-      - name: cargo fmt
-        run: cargo fmt --all -- --check
-
-  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 }}
+    name: Test
     runs-on: ubuntu-latest
-
     strategy:
       matrix:
-        include:
-          - name: stable
-            rust: stable
-          - name: beta
-            rust: beta
-          - name: 1.45.2
-            rust: 1.45.2
-
+        rust:
+          - stable
+          - beta
+          - 1.40.0
     steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Setup cache
-        uses: actions/cache@v2
+      - uses: actions/checkout@v1
+      - uses: actions-rs/toolchain@v1
         with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-          key: ${{ runner.os }}-cargo-test-${{ matrix.rust }}
+          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
 
-      - name: Install rust
-        run: |
-          rustup default ${{ matrix.rust }}
-          rustup update --no-self-update ${{ matrix.rust }}
+  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: Install postfix  
-        run: |
-          DEBIAN_FRONTEND=noninteractive sudo apt-get update
-          DEBIAN_FRONTEND=noninteractive sudo apt-get -y install postfix
+  fmt:
+    name: Rustfmt
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
 
-      - name: Run SMTP server
-        run: smtp-sink 2525 1000&
+  clippy:
+    name: Clippy
+    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
 
-      - 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@v2
+#      - uses: actions/checkout@v1
 #      - uses: actions-rs/toolchain@v1
 #        with:
 #          toolchain: nightly

CHANGELOG.md

@@ -5,8 +5,7 @@
 
 Several breaking changes were made between 0.9 and 0.10, but changes should be straightforward:
 
-* MSRV is now 1.45.2
-* The `lettre_email` crate has been merged into `lettre`. To migrate, replace `lettre_email` with `lettre::message`
+* The `lettre_email` crate has been merged into `lettre`. To migrate, replace `lettre_email` with `lettre::builder`
   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`.
@@ -14,46 +13,33 @@ Several breaking changes were made between 0.9 and 0.10, but changes should be s
 
 #### Features
 
-* Add `tokio` 0.2 and 1.0 support
-* Add `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
+* 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))
 
-#### Breaking Changes
+#### Changes
 
-* 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)
+* 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)
 * The `new` method of `ClientId` is deprecated
-* Rename `serde-impls` feature to `serde`
-
 
 #### Bug Fixes
 
-* 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
+* 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))
 
 <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.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.
+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.
 
 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,10 +1,9 @@
 [package]
 name = "lettre"
-# remember to update html_root_url and README.md (Cargo.toml example and deps.rs badge)
-version = "0.10.0-beta.3"
+version = "0.10.0-alpha.2" # remember to update html_root_url and README.md
 description = "Email client"
 readme = "README.md"
-homepage = "https://lettre.rs"
+homepage = "https://lettre.at"
 repository = "https://github.com/lettre/lettre"
 license = "MIT"
 authors = ["Alexis Mousset <contact@amousset.me>", "Paolo Barbolini <paolo@paolo565.org>"]
@@ -18,51 +17,33 @@ is-it-maintained-open-issues = { repository = "lettre/lettre" }
 maintenance = { status = "actively-developed" }
 
 [dependencies]
-idna = "0.2"
-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 }
-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 }
-
-# smtp
-nom = { version = "6", default-features = false, features = ["alloc", "std"], 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.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-attributes = { version = "1.1", optional = true }
+async-std = { version = "1.5", optional = true, features = ["unstable"] }
 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 }
+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"
+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 }
+serde = { version = "1", optional = true, features = ["derive"] }
+serde_json = { version = "1", optional = true }
+uuid = { version = "0.8", features = ["v4"] }
+webpki = { version = "0.21", optional = true }
+webpki-roots = { version = "0.20", optional = true }
 
 [dev-dependencies]
 criterion = "0.3"
@@ -70,86 +51,43 @@ 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]
-default = ["smtp-transport", "native-tls", "hostname", "r2d2", "builder"]
-builder = ["mime", "base64", "hyperx", "rand", "quoted_printable"]
-
-# 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"]
+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"]
-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"]
+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"]
+sendmail-transport = []
+smtp-transport = ["base64", "nom"]
 
 [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", "builder"]
+required-features = ["smtp-transport"]
 
 [[example]]
 name = "smtp_tls"
-required-features = ["smtp-transport", "native-tls", "builder"]
+required-features = ["smtp-transport", "native-tls"]
 
 [[example]]
 name = "smtp_starttls"
-required-features = ["smtp-transport", "native-tls", "builder"]
-
-[[example]]
-name = "smtp_selfsigned"
-required-features = ["smtp-transport", "native-tls", "builder"]
+required-features = ["smtp-transport", "native-tls"]
 
 [[example]]
 name = "tokio02_smtp_tls"
-required-features = ["smtp-transport", "tokio02", "tokio02-native-tls", "builder"]
+required-features = ["smtp-transport", "tokio02", "tokio02-native-tls"]
 
 [[example]]
 name = "tokio02_smtp_starttls"
-required-features = ["smtp-transport", "tokio02", "tokio02-native-tls", "builder"]
-
-[[example]]
-name = "tokio1_smtp_tls"
-required-features = ["smtp-transport", "tokio1", "tokio1-native-tls", "builder"]
-
-[[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"]
+required-features = ["smtp-transport", "tokio02", "tokio02-native-tls"]

README.md

@@ -21,19 +21,12 @@
     <img src="https://badges.gitter.im/lettre/lettre.svg"
       alt="chat on gitter" />
   </a>
-  <a href="https://lettre.rs">
+  <a href="https://lettre.at">
     <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.3">
-    <img src="https://deps.rs/crate/lettre/0.10.0-beta.3/status.svg"
-      alt="dependency status" />
-  </a>
-</div>
-
 ---
 
 **NOTE**: this readme refers to the 0.10 version of lettre, which is
@@ -52,7 +45,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
+* Async support (incomplete)
 
 Lettre does not provide (for now):
 
@@ -60,13 +53,13 @@ Lettre does not provide (for now):
 
 ## Example
 
-This library requires Rust 1.45 or newer.
+This library requires Rust 1.40 or newer.
 To use this library, add the following to your `Cargo.toml`:
 
 
 ```toml
 [dependencies]
-lettre = "0.10.0-beta.3"
+lettre = "0.10.0-alpha.2"
 ```
 
 ```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.rs](mailto:security@lettre.rs). Security issues
+Security issues should be reported privately via [security@lettre.at](mailto:security@lettre.at). Security issues
 should not be reported via the public Github Issue tracker.
 
 ## Security advisories

benches/transport_smtp.rs

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

examples/README.md

@@ -1,24 +0,0 @@
-# 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

@@ -1,32 +0,0 @@
-use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncStd1Executor,
-    AsyncTransport, 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

@@ -1,32 +0,0 @@
-use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncStd1Executor,
-    AsyncTransport, 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

@@ -1,53 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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(String::from("Be happy!"))
+        .body("Be happy!")
         .unwrap();
 
     // Open a local connection on port 25

examples/smtp_selfsigned.rs

@@ -1,44 +0,0 @@
-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(String::from("Be happy!"))
+        .body("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(String::from("Be happy!"))
+        .body("Be happy!")
         .unwrap();
 
     let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());

examples/tokio02_smtp_starttls.rs

@@ -4,8 +4,8 @@
 use tokio02_crate as tokio;
 
 use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncTransport, Message,
-    Tokio02Executor,
+    transport::smtp::authentication::Credentials, AsyncSmtpTransport, Message, Tokio02Connector,
+    Tokio02Transport,
 };
 
 #[tokio::main]
@@ -17,17 +17,16 @@ async fn main() {
         .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!"))
+        .body("Be happy with async!")
         .unwrap();
 
     let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
 
     // Open a remote connection to gmail using STARTTLS
-    let mailer: AsyncSmtpTransport<Tokio02Executor> =
-        AsyncSmtpTransport::<Tokio02Executor>::starttls_relay("smtp.gmail.com")
-            .unwrap()
-            .credentials(creds)
-            .build();
+    let mailer = AsyncSmtpTransport::<Tokio02Connector>::starttls_relay("smtp.gmail.com")
+        .unwrap()
+        .credentials(creds)
+        .build();
 
     // Send the email
     match mailer.send(email).await {

examples/tokio02_smtp_tls.rs

@@ -4,8 +4,8 @@
 use tokio02_crate as tokio;
 
 use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncTransport, Message,
-    Tokio02Executor,
+    transport::smtp::authentication::Credentials, AsyncSmtpTransport, Message, Tokio02Connector,
+    Tokio02Transport,
 };
 
 #[tokio::main]
@@ -17,17 +17,16 @@ async fn main() {
         .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!"))
+        .body("Be happy with async!")
         .unwrap();
 
     let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
 
     // Open a remote connection to gmail
-    let mailer: AsyncSmtpTransport<Tokio02Executor> =
-        AsyncSmtpTransport::<Tokio02Executor>::relay("smtp.gmail.com")
-            .unwrap()
-            .credentials(creds)
-            .build();
+    let mailer = AsyncSmtpTransport::<Tokio02Connector>::relay("smtp.gmail.com")
+        .unwrap()
+        .credentials(creds)
+        .build();
 
     // Send the email
     match mailer.send(email).await {

examples/tokio1_smtp_starttls.rs

@@ -1,37 +0,0 @@
-// This line is only to make it compile from lettre's examples folder,
-// since it uses Rust 2018 crate renaming to import tokio.
-// Won't be needed in user's code.
-use tokio1_crate as tokio;
-
-use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncTransport, Message,
-    Tokio1Executor,
-};
-
-#[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

@@ -1,37 +0,0 @@
-// This line is only to make it compile from lettre's examples folder,
-// since it uses Rust 2018 crate renaming to import tokio.
-// Won't be needed in user's code.
-use tokio1_crate as tokio;
-
-use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncTransport, Message,
-    Tokio1Executor,
-};
-
-#[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.rs

@@ -12,41 +12,11 @@ use std::{
     str::FromStr,
 };
 
-/// Represents an email address with a user and a domain name.
+/// Email address
 ///
 /// 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("user", "email.com")?;
-/// assert_eq!(address.user(), "user");
-/// assert_eq!(address.domain(), "email.com");
-/// # Ok(())
-/// # }
-/// ```
-///
-/// You can also create an `Address` from a string literal by parsing it:
-///
-/// ```
-/// use lettre::Address;
-///
-/// # use std::error::Error;
-/// # fn main() -> Result<(), Box<dyn Error>> {
-/// let address = "user@email.com".parse::<Address>()?;
-/// assert_eq!(address.user(), "user");
-/// assert_eq!(address.domain(), "email.com");
-/// # Ok(())
-/// # }
-/// ```
 #[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
 pub struct Address {
     /// Complete address
@@ -55,138 +25,6 @@ pub struct Address {
     at_start: usize,
 }
 
-// Regex from the specs
-// https://html.spec.whatwg.org/multipage/forms.html#valid-e-mail-address
-// It will mark esoteric email addresses like quoted string as invalid
-static USER_RE: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r"^(?i)[a-z0-9.!#$%&'*+/=?^_`{|}~-]+\z").unwrap());
-static DOMAIN_RE: Lazy<Regex> = Lazy::new(|| {
-    Regex::new(
-        r"(?i)^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$",
-    )
-    .unwrap()
-});
-// literal form, ipv4 or ipv6 address (SMTP 4.1.3)
-static LITERAL_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"(?i)\[([A-f0-9:\.]+)\]\z").unwrap());
-
-impl Address {
-    /// 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("user", "email.com")?;
-    /// let expected = "user@email.com".parse::<Address>()?;
-    /// 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()
-    }
-
-    /// 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("user", "email.com")?;
-    /// assert_eq!(address.user(), "user");
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn user(&self) -> &str {
-        &self.serialized[..self.at_start]
-    }
-
-    /// 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("user", "email.com")?;
-    /// assert_eq!(address.domain(), "email.com");
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn domain(&self) -> &str {
-        &self.serialized[self.at_start + 1..]
-    }
-
-    pub(super) fn check_user(user: &str) -> Result<(), AddressError> {
-        if USER_RE.is_match(user) {
-            Ok(())
-        } else {
-            Err(AddressError::InvalidUser)
-        }
-    }
-
-    pub(super) fn check_domain(domain: &str) -> Result<(), AddressError> {
-        Address::check_domain_ascii(domain).or_else(|_| {
-            domain_to_ascii(domain)
-                .map_err(|_| AddressError::InvalidDomain)
-                .and_then(|domain| Address::check_domain_ascii(&domain))
-        })
-    }
-
-    fn check_domain_ascii(domain: &str) -> Result<(), AddressError> {
-        if DOMAIN_RE.is_match(domain) {
-            return Ok(());
-        }
-
-        if let Some(caps) = LITERAL_RE.captures(domain) {
-            if let Some(cap) = caps.get(1) {
-                if cap.as_str().parse::<IpAddr>().is_ok() {
-                    return Ok(());
-                }
-            }
-        }
-
-        Err(AddressError::InvalidDomain)
-    }
-
-    #[cfg(feature = "smtp-transport")]
-    /// 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 {
-        f.write_str(&self.serialized)
-    }
-}
-
-impl FromStr for Address {
-    type Err = AddressError;
-
-    fn from_str(val: &str) -> Result<Self, AddressError> {
-        let mut parts = val.rsplitn(2, '@');
-        let domain = parts.next().ok_or(AddressError::MissingParts)?;
-        let user = parts.next().ok_or(AddressError::MissingParts)?;
-
-        Address::check_user(user)?;
-        Address::check_domain(domain)?;
-        Ok(Address {
-            serialized: val.into(),
-            at_start: user.len(),
-        })
-    }
-}
-
 impl<U, D> TryFrom<(U, D)> for Address
 where
     U: AsRef<str>,
@@ -209,6 +47,92 @@ where
     }
 }
 
+// Regex from the specs
+// https://html.spec.whatwg.org/multipage/forms.html#valid-e-mail-address
+// It will mark esoteric email addresses like quoted string as invalid
+static USER_RE: Lazy<Regex> =
+    Lazy::new(|| Regex::new(r"^(?i)[a-z0-9.!#$%&'*+/=?^_`{|}~-]+\z").unwrap());
+static DOMAIN_RE: Lazy<Regex> = Lazy::new(|| {
+    Regex::new(
+        r"(?i)^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$",
+    )
+    .unwrap()
+});
+// literal form, ipv4 or ipv6 address (SMTP 4.1.3)
+static LITERAL_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"(?i)\[([A-f0-9:\.]+)\]\z").unwrap());
+
+impl Address {
+    /// Create email address from parts
+    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`
+    pub fn user(&self) -> &str {
+        &self.serialized[..self.at_start]
+    }
+
+    /// Get the domain part of this `Address`
+    pub fn domain(&self) -> &str {
+        &self.serialized[self.at_start + 1..]
+    }
+
+    fn check_user(user: &str) -> Result<(), AddressError> {
+        if USER_RE.is_match(user) {
+            Ok(())
+        } else {
+            Err(AddressError::InvalidUser)
+        }
+    }
+
+    fn check_domain(domain: &str) -> Result<(), AddressError> {
+        Address::check_domain_ascii(domain).or_else(|_| {
+            domain_to_ascii(domain)
+                .map_err(|_| AddressError::InvalidDomain)
+                .and_then(|domain| Address::check_domain_ascii(&domain))
+        })
+    }
+
+    fn check_domain_ascii(domain: &str) -> Result<(), AddressError> {
+        if DOMAIN_RE.is_match(domain) {
+            return Ok(());
+        }
+
+        if let Some(caps) = LITERAL_RE.captures(domain) {
+            if let Some(cap) = caps.get(1) {
+                if cap.as_str().parse::<IpAddr>().is_ok() {
+                    return Ok(());
+                }
+            }
+        }
+
+        Err(AddressError::InvalidDomain)
+    }
+}
+
+impl Display for Address {
+    fn fmt(&self, f: &mut Formatter) -> FmtResult {
+        f.write_str(&self.serialized)
+    }
+}
+
+impl FromStr for Address {
+    type Err = AddressError;
+
+    fn from_str(val: &str) -> Result<Self, AddressError> {
+        let mut parts = val.rsplitn(2, '@');
+        let domain = parts.next().ok_or(AddressError::MissingParts)?;
+        let user = parts.next().ok_or(AddressError::MissingParts)?;
+
+        Address::check_user(user)?;
+        Address::check_domain(domain)?;
+        Ok(Address {
+            serialized: val.into(),
+            at_start: user.len(),
+        })
+    }
+}
+
 impl AsRef<str> for Address {
     fn as_ref(&self) -> &str {
         &self.serialized
@@ -222,7 +146,6 @@ impl AsRef<OsStr> for Address {
 }
 
 #[derive(Debug, PartialEq, Clone, Copy)]
-/// Errors in email addresses parsing
 pub enum AddressError {
     MissingParts,
     Unbalanced,
@@ -234,7 +157,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"),
@@ -245,6 +168,120 @@ 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/address/envelope.rs

@@ -1,146 +0,0 @@
-#[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
-    ///
-    /// ```rust
-    /// # use lettre::address::{Address, Envelope};
-    /// # use std::error::Error;
-    /// # fn main() -> Result<(), Box<dyn Error>> {
-    /// let sender = "sender@email.com".parse::<Address>()?;
-    /// let recipients = vec!["to@email.com".parse::<Address>()?];
-    ///
-    /// 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
-    ///
-    /// ```rust
-    /// # use lettre::address::{Address, Envelope};
-    /// # use std::error::Error;
-    /// # fn main() -> Result<(), Box<dyn Error>> {
-    /// let sender = "from@email.com".parse::<Address>()?;
-    /// let recipients = vec!["to@email.com".parse::<Address>()?];
-    ///
-    /// 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
-    ///
-    /// ```rust
-    /// # use lettre::address::{Address, Envelope};
-    /// # use std::error::Error;
-    /// # fn main() -> Result<(), Box<dyn Error>> {
-    /// let sender = "from@email.com".parse::<Address>()?;
-    /// let recipients = vec!["to@email.com".parse::<Address>()?];
-    ///
-    /// 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()
-    }
-
-    #[cfg(feature = "smtp-transport")]
-    /// 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

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

src/address/serde.rs

@@ -1,112 +0,0 @@
-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/error.rs

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

src/executor.rs

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

@@ -4,183 +4,206 @@
 //! * Pluggable email transports
 //! * Unicode support
 //! * Secure defaults
-//! * Async support
 //!
-//! Lettre requires Rust 1.45 or newer.
+//! Lettre requires Rust 1.40 or newer.
 //!
-//! ## Features
+//! ## Optional features
 //!
-//! This section lists each lettre feature and briefly explains it.
-//! More info about each module can be found in the corresponding module page.
-//!
-//! Features with `📫` near them are enabled by default.
-//!
-//! ### Typed message builder
-//!
-//! _Strongly typed [`message`] builder_
-//!
-//! * **builder** 📫: Enable the [`Message`] builder
-//! * **hostname** 📫: Try to use the actual system hostname in the `Message-ID` header
-//!
-//! ### SMTP transport
-//!
-//! _Send emails using [`SMTP`]_
-//!
-//! * **smtp-transport** 📫: Enable the SMTP transport
-//! * **r2d2** 📫: Connection pool for SMTP transport
-//! * **hostname** 📫: Try to use the actual system hostname for the SMTP `CLIENTID`
-//!
-//! #### SMTP over TLS via the native-tls crate
-//!
-//! _Secure SMTP connections using TLS from the `native-tls` crate_
-//!
-//! Uses schannel on Windows, Security-Framework on macOS, and OpenSSL on Linux.
-//!
-//! * **native-tls** 📫: TLS support for the synchronous version of the API
-//! * **tokio02-native-tls**: TLS support for the `tokio02` async version of the API
-//! * **tokio1-native-tls**: TLS support for the `tokio1` async version of the API
-//!
-//! NOTE: native-tls isn't supported with `async-std`
-//!
-//! #### SMTP over TLS via the rustls crate
-//!
-//! _Secure SMTP connections using TLS from the `rustls-tls` crate_
-//!
-//! Rustls uses [ring] as the cryptography implementation. As a result, [not all Rust's targets are supported][ring-support].
-//!
-//! * **rustls-tls**: TLS support for the synchronous version of the API
-//! * **tokio02-rustls-tls**: TLS support for the `tokio02` async version of the API
-//! * **tokio1-rustls-tls**: TLS support for the `tokio1` async version of the API
-//! * **async-std1-rustls-tls**: TLS support for the `async-std1` async version of the API
-//!
-//! ### Sendmail transport
-//!
-//! _Send emails using the [`sendmail`] command_
-//!
-//! * **sendmail-transport**: Enable the `sendmail` transport
-//!
-//! ### File transport
-//!
-//! _Save emails as an `.eml` [`file`]_
-//!
-//! * **file-transport**: Enable the file transport (saves emails into an `.eml` file)
-//! * **file-transport-envelope**: Allow writing the envelope into a JSON file (additionally saves envelopes into a `.json` file)
-//!
-//! ### Async execution runtimes
-//!
-//! _Use [tokio] or [async-std] as an async execution runtime for sending emails_
-//!
-//! The correct runtime version must be chosen in order for lettre to work correctly.
-//! For example, when sending emails from a Tokio 1.3.0 context, the Tokio 1.x executor
-//! ([`Tokio1Executor`]) must be used. Using a different version (for example Tokio 0.2.x),
-//! or async-std, would result in a runtime panic.
-//!
-//! * **tokio02**: Allow to asynchronously send emails using [Tokio 0.2.x]
-//! * **tokio1**: Allow to asynchronously send emails using [Tokio 1.x]
-//! * **async-std1**: Allow to asynchronously send emails using [async-std 1.x]
-//!
-//! NOTE: native-tls isn't supported with `async-std`
-//!
-//! ### Misc features
-//!
-//! _Additional features_
-//!
-//! * **serde**: Serialization/Deserialization of entities
+//! * **builder**: Message builder
+//! * **file-transport**: Transport that write messages into a file
+//! * **smtp-transport**: Transport over SMTP
+//! * **sendmail-transport**: Transport over SMTP
+//! * **rustls-tls**: TLS support with the `rustls` crate
+//! * **native-tls**: TLS support with the `native-tls` crate
+//! * **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)
+//! * **r2d2**: Connection pool for SMTP transport
 //! * **tracing**: Logging using the `tracing` crate
-//!
-//! [`SMTP`]: crate::transport::smtp
-//! [`sendmail`]: crate::transport::sendmail
-//! [`file`]: crate::transport::file
-//! [tokio]: https://docs.rs/tokio/1
-//! [async-std]: https://docs.rs/async-std/1
-//! [ring]: https://github.com/briansmith/ring#ring
-//! [ring-support]: https://github.com/briansmith/ring#online-automated-testing
-//! [Tokio 0.2.x]: https://docs.rs/tokio/0.2
-//! [Tokio 1.x]: https://docs.rs/tokio/1
-//! [async-std 1.x]: https://docs.rs/async-std/1
+//! * **serde**: Serialization/Deserialization of entities
+//! * **hostname**: Ability to try to use actual hostname in SMTP transaction
 
-#![doc(html_root_url = "https://docs.rs/crate/lettre/0.10.0-beta.3")]
+#![doc(html_root_url = "https://docs.rs/crate/lettre/0.10.0-alpha.2")]
 #![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,
-    rust_2018_idioms
+    unsafe_code
 )]
-#![cfg_attr(docsrs, feature(doc_cfg))]
 
 pub mod address;
 pub mod error;
-#[cfg(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")]
-#[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")))]
-#[doc(inline)]
-pub use self::transport::AsyncTransport;
-pub use crate::address::Address;
-#[cfg(feature = "builder")]
-#[doc(inline)]
-pub use crate::message::Message;
-#[cfg(all(
-    feature = "file-transport",
-    any(feature = "tokio02", feature = "tokio1", feature = "async-std1")
-))]
-#[doc(inline)]
-pub use crate::transport::file::AsyncFileTransport;
+pub use crate::message::{
+    header::{self, Headers},
+    EmailFormat, Mailbox, Mailboxes, Message,
+};
 #[cfg(feature = "file-transport")]
-#[doc(inline)]
 pub use crate::transport::file::FileTransport;
-#[cfg(all(
-    feature = "sendmail-transport",
-    any(feature = "tokio02", feature = "tokio1", feature = "async-std1")
-))]
-#[doc(inline)]
-pub use crate::transport::sendmail::AsyncSendmailTransport;
 #[cfg(feature = "sendmail-transport")]
-#[doc(inline)]
 pub use crate::transport::sendmail::SendmailTransport;
-#[cfg(all(
-    feature = "smtp-transport",
-    any(feature = "tokio02", feature = "tokio1", feature = "async-std1")
-))]
-pub use crate::transport::smtp::AsyncSmtpTransport;
-#[doc(inline)]
-pub use crate::transport::Transport;
-use crate::{address::Envelope, error::Error};
-
+#[cfg(all(feature = "smtp-transport", feature = "connection-pool"))]
+pub use crate::transport::smtp::r2d2::SmtpConnectionManager;
 #[cfg(feature = "smtp-transport")]
 pub use crate::transport::smtp::SmtpTransport;
-use std::error::Error as StdError;
+#[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;
 
-pub(crate) type BoxError = Box<dyn StdError + Send + Sync>;
+/// 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
+#[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
+#[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>;
+}
 
 #[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

@@ -1,581 +0,0 @@
-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

@@ -0,0 +1,250 @@
+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,16 +7,6 @@ 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,
@@ -29,18 +19,19 @@ pub enum ContentTransferEncoding {
 
 impl Default for ContentTransferEncoding {
     fn default() -> Self {
-        ContentTransferEncoding::Base64
+        ContentTransferEncoding::SevenBit
     }
 }
 
 impl Display for ContentTransferEncoding {
-    fn fmt(&self, f: &mut FmtFormatter<'_>) -> FmtResult {
+    fn fmt(&self, f: &mut FmtFormatter) -> FmtResult {
+        use self::ContentTransferEncoding::*;
         f.write_str(match *self {
-            Self::SevenBit => "7bit",
-            Self::QuotedPrintable => "quoted-printable",
-            Self::Base64 => "base64",
-            Self::EightBit => "8bit",
-            Self::Binary => "binary",
+            SevenBit => "7bit",
+            QuotedPrintable => "quoted-printable",
+            Base64 => "base64",
+            EightBit => "8bit",
+            Binary => "binary",
         })
     }
 }
@@ -48,12 +39,13 @@ 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(Self::SevenBit),
-            "quoted-printable" => Ok(Self::QuotedPrintable),
-            "base64" => Ok(Self::Base64),
-            "8bit" => Ok(Self::EightBit),
-            "binary" => Ok(Self::Binary),
+            "7bit" => Ok(SevenBit),
+            "quoted-printable" => Ok(QuotedPrintable),
+            "base64" => Ok(Base64),
+            "8bit" => Ok(EightBit),
+            "binary" => Ok(Binary),
             _ => Err(s.into()),
         }
     }
@@ -79,7 +71,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,4 +1,8 @@
-//! Headers widely used in email messages
+/*!
+
+## Headers widely used in email messages
+
+*/
 
 mod content;
 mod mailbox;

src/message/header/special.rs

@@ -5,7 +5,6 @@ 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,
@@ -46,7 +45,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,9 +6,8 @@ use hyperx::{
 use std::{fmt::Result as FmtResult, str::from_utf8};
 
 macro_rules! text_header {
-    ($(#[$attr:meta])* Header($type_name: ident, $header_name: expr )) => {
+    ( $type_name: ident, $header_name: expr ) => {
         #[derive(Debug, Clone, PartialEq)]
-        $(#[$attr])*
         pub struct $type_name(pub String);
 
         impl Header for $type_name {
@@ -27,48 +26,20 @@ 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` 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")
-);
+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");
 
 fn parse_text(raw: &[u8]) -> HyperResult<String> {
     if let Ok(src) = from_utf8(raw) {
@@ -79,7 +50,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,60 +9,22 @@ use std::{
     str::FromStr,
 };
 
-/// Represents an email address with an optional name for the sender/recipient.
+/// Email address with optional addressee name
 ///
 /// 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 {
-    /// The name associated with the address.
+    /// User name part
     pub name: Option<String>,
 
-    /// The email address itself.
+    /// Email address part
     pub email: Address,
 }
 
 impl Mailbox {
-    /// 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(())
-    /// # }
-    /// ```
+    /// Create new mailbox using email address and addressee name
     pub fn new(name: Option<String>, email: Address) -> Self {
         Mailbox { name, email }
     }
@@ -77,7 +39,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() {
@@ -137,7 +99,7 @@ impl FromStr for Mailbox {
     }
 }
 
-/// Represents a sequence of [`Mailbox`] instances.
+/// List or email mailboxes
 ///
 /// This type contains a sequence of mailboxes (_Some Name \<user@domain.tld\>, Another Name \<other@domain.tld\>, withoutname@domain.tld, ..._).
 ///
@@ -146,119 +108,29 @@ impl FromStr for Mailbox {
 pub struct Mailboxes(Vec<Mailbox>);
 
 impl Mailboxes {
-    /// Creates a new list of [`Mailbox`] instances.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lettre::message::Mailboxes;
-    /// let mailboxes = Mailboxes::new();
-    /// ```
+    /// Create mailboxes list
     pub fn new() -> Self {
         Mailboxes(Vec::new())
     }
 
-    /// 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(())
-    /// # }
-    /// ```
+    /// Add mailbox to a list
     pub fn with(mut self, mbox: Mailbox) -> Self {
         self.0.push(mbox);
         self
     }
 
-    /// 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(())
-    /// # }
-    /// ```
+    /// Add mailbox to a list
     pub fn push(&mut self, mbox: Mailbox) {
         self.0.push(mbox);
     }
 
-    /// 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(())
-    /// # }
-    /// ```
+    /// Extract first mailbox
     pub fn into_single(self) -> Option<Mailbox> {
         self.into()
     }
 
-    /// 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> {
+    /// Iterate over mailboxes
+    pub fn iter(&self) -> Iter<Mailbox> {
         self.0.iter()
     }
 }
@@ -270,26 +142,26 @@ impl Default for Mailboxes {
 }
 
 impl From<Mailbox> for Mailboxes {
-    fn from(mailbox: Mailbox) -> Self {
-        Mailboxes(vec![mailbox])
+    fn from(single: Mailbox) -> Self {
+        Mailboxes(vec![single])
     }
 }
 
-impl From<Mailboxes> for Option<Mailbox> {
-    fn from(mailboxes: Mailboxes) -> Option<Mailbox> {
-        mailboxes.into_iter().next()
+impl Into<Option<Mailbox>> for Mailboxes {
+    fn into(self) -> Option<Mailbox> {
+        self.into_iter().next()
     }
 }
 
 impl From<Vec<Mailbox>> for Mailboxes {
-    fn from(vec: Vec<Mailbox>) -> Self {
-        Mailboxes(vec)
+    fn from(list: Vec<Mailbox>) -> Self {
+        Mailboxes(list)
     }
 }
 
-impl From<Mailboxes> for Vec<Mailbox> {
-    fn from(mailboxes: Mailboxes) -> Vec<Mailbox> {
-        mailboxes.0
+impl Into<Vec<Mailbox>> for Mailboxes {
+    fn into(self) -> Vec<Mailbox> {
+        self.0
     }
 }
 
@@ -311,7 +183,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,17 +1,21 @@
 use crate::message::{
+    encoder::codec,
     header::{ContentTransferEncoding, ContentType, Header, Headers},
-    EmailFormat, IntoBody,
+    EmailFormat,
 };
 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),
 }
 
@@ -34,9 +38,11 @@ impl Part {
 }
 
 /// Parts of multipart body
+///
 pub type Parts = Vec<Part>;
 
 /// Creates builder for single part
+///
 #[derive(Debug, Clone)]
 pub struct SinglePartBuilder {
     headers: Headers,
@@ -63,15 +69,10 @@ impl SinglePartBuilder {
     }
 
     /// Build singlepart using body
-    pub fn body<T: IntoBody>(mut self, body: T) -> SinglePart {
-        let maybe_encoding = self.headers.get::<ContentTransferEncoding>().copied();
-        let body = body.into_body(maybe_encoding);
-
-        self.headers.set(body.encoding());
-
+    pub fn body<T: Into<Vec<u8>>>(self, body: T) -> SinglePart {
         SinglePart {
             headers: self.headers,
-            body: body.into_vec(),
+            body: body.into(),
         }
     }
 }
@@ -87,16 +88,14 @@ impl Default for SinglePartBuilder {
 /// # Example
 ///
 /// ```
-/// use lettre::message::{header, SinglePart};
+/// use lettre::message::{SinglePart, header};
 ///
-/// # use std::error::Error;
-/// # fn main() -> Result<(), Box<dyn Error>> {
 /// let part = SinglePart::builder()
-///     .header(header::ContentType("text/plain; charset=utf8".parse()?))
-///     .body(String::from("Текст письма в уникоде"));
-/// # Ok(())
-/// # }
+///      .header(header::ContentType("text/plain; charset=utf8".parse().unwrap()))
+///      .header(header::ContentTransferEncoding::Binary)
+///      .body("Текст письма в уникоде");
 /// ```
+///
 #[derive(Debug, Clone)]
 pub struct SinglePart {
     headers: Headers,
@@ -104,25 +103,57 @@ pub struct SinglePart {
 }
 
 impl SinglePart {
-    /// Creates a builder for singlepart
-    #[inline]
+    /// Creates a default builder for singlepart
     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
     }
 
-    /// Get the encoded body
-    #[inline]
-    pub fn raw_body(&self) -> &[u8] {
+    /// Read the body from singlepart
+    pub fn body_ref(&self) -> &[u8] {
         &self.body
     }
 
-    /// Get message content formatted for sending
+    /// Get message content formatted for SMTP
     pub fn formatted(&self) -> Vec<u8> {
         let mut out = Vec::new();
         self.format(&mut out);
@@ -134,12 +165,17 @@ 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");
-        out.extend_from_slice(&self.body);
+
+        let encoding = self.headers.get::<ContentTransferEncoding>();
+        let mut encoder = codec(encoding);
+
+        out.extend_from_slice(&encoder.encode(&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
@@ -167,9 +203,8 @@ pub enum MultiPartKind {
 /// Create a random MIME boundary.
 fn make_boundary() -> String {
     rand::thread_rng()
-        .sample_iter(rand::distributions::Alphanumeric)
-        .take(40)
-        .map(char::from)
+        .sample_iter(&rand::distributions::Alphanumeric)
+        .take(68)
         .collect()
 }
 
@@ -177,19 +212,20 @@ impl MultiPartKind {
     fn to_mime<S: Into<String>>(&self, boundary: Option<S>) -> Mime {
         let boundary = boundary.map_or_else(make_boundary, |s| s.into());
 
+        use self::MultiPartKind::*;
         format!(
             "multipart/{}; boundary=\"{}\"{}",
             match self {
-                Self::Mixed => "mixed",
-                Self::Alternative => "alternative",
-                Self::Related => "related",
-                Self::Encrypted { .. } => "encrypted",
-                Self::Signed { .. } => "signed",
+                Mixed => "mixed",
+                Alternative => "alternative",
+                Related => "related",
+                Encrypted { .. } => "encrypted",
+                Signed { .. } => "signed",
             },
             boundary,
             match self {
-                Self::Encrypted { protocol } => format!("; protocol=\"{}\"", protocol),
-                Self::Signed { protocol, micalg } =>
+                Encrypted { protocol } => format!("; protocol=\"{}\"", protocol),
+                Signed { protocol, micalg } =>
                     format!("; protocol=\"{}\"; micalg=\"{}\"", protocol, micalg),
                 _ => String::new(),
             }
@@ -199,17 +235,18 @@ impl MultiPartKind {
     }
 
     fn from_mime(m: &Mime) -> Option<Self> {
+        use self::MultiPartKind::*;
         match m.subtype().as_ref() {
-            "mixed" => Some(Self::Mixed),
-            "alternative" => Some(Self::Alternative),
-            "related" => Some(Self::Related),
+            "mixed" => Some(Mixed),
+            "alternative" => Some(Alternative),
+            "related" => Some(Related),
             "signed" => m.get_param("protocol").and_then(|p| {
-                m.get_param("micalg").map(|micalg| Self::Signed {
+                m.get_param("micalg").map(|micalg| Signed {
                     protocol: p.as_str().to_owned(),
                     micalg: micalg.as_str().to_owned(),
                 })
             }),
-            "encrypted" => m.get_param("protocol").map(|p| Self::Encrypted {
+            "encrypted" => m.get_param("protocol").map(|p| Encrypted {
                 protocol: p.as_str().to_owned(),
             }),
             _ => None,
@@ -224,6 +261,7 @@ impl From<MultiPartKind> for Mime {
 }
 
 /// Multipart builder
+///
 #[derive(Debug, Clone)]
 pub struct MultiPartBuilder {
     headers: Headers,
@@ -289,6 +327,7 @@ impl Default for MultiPartBuilder {
 }
 
 /// Multipart variant with parts
+///
 #[derive(Debug, Clone)]
 pub struct MultiPart {
     headers: Headers,
@@ -496,7 +535,7 @@ mod test {
                         parameters: vec![header::DispositionParam::Filename(
                             header::Charset::Ext("utf-8".into()),
                             None,
-                            "example.c".into(),
+                            "example.c".as_bytes().into(),
                         )],
                     })
                     .header(header::ContentTransferEncoding::Binary)
@@ -543,7 +582,7 @@ mod test {
                         parameters: vec![header::DispositionParam::Filename(
                             header::Charset::Ext("utf-8".into()),
                             None,
-                            "encrypted.asc".into(),
+                            "encrypted.asc".as_bytes().into(),
                         )],
                     })
                     .body(String::from(concat!(
@@ -561,13 +600,11 @@ 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",
@@ -600,7 +637,7 @@ mod test {
                     parameters: vec![header::DispositionParam::Filename(
                         header::Charset::Ext("utf-8".into()),
                         None,
-                        "signature.asc".into(),
+                        "signature.asc".as_bytes().into(),
                     )],
                 })
                 .body(String::from(concat!(
@@ -622,13 +659,11 @@ 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",
@@ -690,7 +725,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".into())]
+                                 parameters: vec![header::DispositionParam::Filename(header::Charset::Ext("utf-8".into()), None, "example.c".as_bytes().into())]
                              })
                              .header(header::ContentTransferEncoding::Binary)
                              .body(String::from("int main() { return 0; }")));
@@ -738,7 +773,7 @@ mod test {
 
         // Ensure correct length
         for boundary in boundaries {
-            assert_eq!(40, boundary.len());
+            assert_eq!(68, boundary.len());
         }
     }
 }

src/message/mod.rs

@@ -1,98 +1,67 @@
 //! Provides a strongly typed way to build emails
 //!
+//! ### Creating messages
+//!
+//! This section explains how to create emails.
+//!
 //! ## Usage
 //!
-//! This section demonstrates how to build messages.
+//! ### Format email messages
 //!
-//! <!--
-//! 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>
+//! #### With string body
 //!
-//!
-//! ### Plain body
-//!
-//! The easiest way of creating a message, which uses a plain text body.
+//! The easiest way how we can create email message with simple string.
 //!
 //! ```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()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
+//!     .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!"))?;
-//! # Ok(())
-//! # }
+//!     .body("Be happy!")
+//!     .unwrap();
 //! ```
 //!
-//! Which produces:
-//! <details>
-//! <summary>Click to expand</summary>
+//! Will produce:
 //!
 //! ```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 is encoded using _UTF8-Base64_ encoding, when necessary.
+//! The unicode header data will be encoded using _UTF8-Base64_ encoding.
 //!
-//! The `Content-Transfer-Encoding` is chosen based on the best encoding
-//! available for the given body, between `7bit`, `quoted-printable` and `base64`.
+//! ### With MIME body
 //!
-//! ### Plain and HTML body
+//! ##### Single part
 //!
-//! Uses a MIME body to include both plain text and HTML versions of the body.
+//! The more complex way is using MIME contents.
 //!
 //! ```rust
-//! # use std::error::Error;
-//! use lettre::message::{header, Message, MultiPart, Part, SinglePart};
+//! use lettre::message::{header, Message, SinglePart, Part};
 //!
-//! # fn main() -> Result<(), Box<dyn Error>> {
 //! let m = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
+//!     .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::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(())
-//! # }
+//!     .singlepart(
+//!         SinglePart::builder()
+//!             .header(header::ContentType(
+//!                 "text/plain; charset=utf8".parse().unwrap(),
+//!             )).header(header::ContentTransferEncoding::QuotedPrintable)
+//!             .body("Привет, мир!"),
+//!     )
+//!     .unwrap();
 //! ```
 //!
-//! Which produces:
-//! <details>
-//! <summary>Click to expand</summary>
+//! The body will be encoded using selected `Content-Transfer-Encoding`.
 //!
 //! ```sh
 //! From: NoBody <nobody@domain.tld>
@@ -100,170 +69,133 @@
 //! 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: 7bit
+//! Content-Transfer-Encoding: quoted-printable
 //!
-//! Hello, world! :)
-//! --0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1
-//! Content-Type: text/html; charset=utf8
-//! Content-Transfer-Encoding: 7bit
+//! =D0=9F=D1=80=D0=B8=D0=B2=D0=B5=D1=82, =D0=BC=D0=B8=D1=80!
 //!
-//! <p><b>Hello</b>, <i>world</i>! <img src="cid:123"></p>
-//! --0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1--
 //! ```
-//! </details>
 //!
-//! ### Complex MIME body
+//! ##### Multiple parts
 //!
-//! This example shows how to include both plain and HTML versions of the body,
-//! attachments and inlined images.
+//! And more advanced way of building message by using multipart MIME contents.
 //!
 //! ```rust
-//! # 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);
+//! use lettre::message::{header, Message, MultiPart, SinglePart, Part};
 //!
 //! let m = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
+//!     .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::mixed()
-//!             .multipart(
-//!                 MultiPart::alternative()
-//!                     .singlepart(
-//!                         SinglePart::builder()
-//!                             .header(header::ContentType("text/plain; charset=utf8".parse()?))
-//!                             .body(String::from("Hello, world! :)")),
-//!                     )
-//!                     .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),
-//!                             ),
-//!                     ),
-//!             )
+//!         .multipart(
+//!             MultiPart::alternative()
 //!             .singlepart(
-//!                 SinglePart::builder()
-//!                     .header(header::ContentType("text/plain; charset=utf8".parse()?))
+//!                 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::Attachment,
-//!                         parameters: vec![header::DispositionParam::Filename(
-//!                             header::Charset::Ext("utf-8".into()),
-//!                             None,
-//!                             "example.rs".as_bytes().into(),
-//!                         )],
+//!                         disposition: header::DispositionType::Inline,
+//!                         parameters: vec![],
 //!                     })
-//!                     .body(String::from("fn main() { println!(\"Hello, World!\") }")),
-//!             ),
-//!     )?;
-//! # Ok(())
-//! # }
+//!                     .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()
+//!                     )
+//!                 ]
+//!             })
+//!             .body("int main() { return 0; }")
+//!         )
+//!     ).unwrap();
 //! ```
 //!
-//! 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
-//! Date: Sat, 12 Dec 2020 16:30:45 GMT
-//! Content-Type: multipart/mixed; boundary="0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1"
+//! Content-Type: multipart/mixed; boundary="RTxPCn9p31oAAAAAeQxtr1FbXr/i5vW1hFlH9oJqZRMWxRMK1QLjQ4OPqFk9R+0xUb/m"
 //!
-//! --0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1
-//! Content-Type: multipart/alternative; boundary="EyXdAZIgZuyUjAounq4Aj44a6MpJfqCKhm6pE1zk"
+//! --RTxPCn9p31oAAAAAeQxtr1FbXr/i5vW1hFlH9oJqZRMWxRMK1QLjQ4OPqFk9R+0xUb/m
+//! Content-Type: multipart/alternative; boundary="qW9QCn9p31oAAAAAodFBg1L1Qrraa5hEl0bDJ6kfJMUcRT2LLSWEoeyhSEbUBIqbjWqy"
 //!
-//! --EyXdAZIgZuyUjAounq4Aj44a6MpJfqCKhm6pE1zk
+//! --qW9QCn9p31oAAAAAodFBg1L1Qrraa5hEl0bDJ6kfJMUcRT2LLSWEoeyhSEbUBIqbjWqy
+//! Content-Transfer-Encoding: quoted-printable
 //! Content-Type: text/plain; charset=utf8
-//! Content-Transfer-Encoding: 7bit
 //!
-//! Hello, world! :)
-//! --EyXdAZIgZuyUjAounq4Aj44a6MpJfqCKhm6pE1zk
-//! Content-Type: multipart/related; boundary="eM5Z18WZVOQsqi5GQ71XGAXk6NNvHUA1Xv1FWrXr"
+//! =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"
 //!
-//! --eM5Z18WZVOQsqi5GQ71XGAXk6NNvHUA1Xv1FWrXr
+//! --BV5RCn9p31oAAAAAUt42E9bYMDEAGCOWlxEz89Bv0qFA5Xsy6rOC3zRahMQ39IFZNnp8
+//! Content-Transfer-Encoding: 8bit
 //! Content-Type: text/html; charset=utf8
-//! Content-Transfer-Encoding: 7bit
 //!
-//! <p><b>Hello</b>, <i>world</i>! <img src=cid:123></p>
-//! --eM5Z18WZVOQsqi5GQ71XGAXk6NNvHUA1Xv1FWrXr
+//! <p><b>Hello</b>, <i>world</i>! <img src=smile.png></p>
+//! --BV5RCn9p31oAAAAAUt42E9bYMDEAGCOWlxEz89Bv0qFA5Xsy6rOC3zRahMQ39IFZNnp8
+//! Content-Transfer-Encoding: base64
 //! Content-Type: image/png
 //! Content-Disposition: inline
-//! Content-ID: <123>
-//! Content-Transfer-Encoding: base64
 //!
 //! PHNtaWxlLXJhdy1pbWFnZS1kYXRhPg==
-//! --eM5Z18WZVOQsqi5GQ71XGAXk6NNvHUA1Xv1FWrXr--
-//! --EyXdAZIgZuyUjAounq4Aj44a6MpJfqCKhm6pE1zk--
-//! --0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1
-//! Content-Type: text/plain; charset=utf8
-//! Content-Disposition: attachment; filename="example.rs"
+//! --BV5RCn9p31oAAAAAUt42E9bYMDEAGCOWlxEz89Bv0qFA5Xsy6rOC3zRahMQ39IFZNnp8--
+//! --qW9QCn9p31oAAAAAodFBg1L1Qrraa5hEl0bDJ6kfJMUcRT2LLSWEoeyhSEbUBIqbjWqy--
+//! --RTxPCn9p31oAAAAAeQxtr1FbXr/i5vW1hFlH9oJqZRMWxRMK1QLjQ4OPqFk9R+0xUb/m
 //! Content-Transfer-Encoding: 7bit
+//! Content-Type: text/plain; charset=utf8
+//! Content-Disposition: attachment; filename="example.c"
+//!
+//! int main() { return 0; }
+//! --RTxPCn9p31oAAAAAeQxtr1FbXr/i5vW1hFlH9oJqZRMWxRMK1QLjQ4OPqFk9R+0xUb/m--
 //!
-//! fn main() { println!("Hello, World!") }
-//! --0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1--
 //! ```
-//! </details>
 
-pub use body::{Body, IntoBody, MaybeString};
+pub use encoder::*;
 pub use mailbox::*;
 pub use mimebody::*;
 
 pub use mime;
 
-mod body;
+mod encoder;
 pub mod header;
 mod mailbox;
 mod mimebody;
 mod utf8_b;
 
-use std::{convert::TryFrom, time::SystemTime};
-
-use uuid::Uuid;
-
 use crate::{
-    address::Envelope,
-    message::header::{ContentTransferEncoding, EmailDate, Header, Headers, MailboxesHeader},
-    Error as EmailError,
+    message::header::{EmailDate, Header, Headers, MailboxesHeader},
+    Envelope, Error as EmailError,
 };
+use std::{convert::TryFrom, time::SystemTime};
+use uuid::Uuid;
 
 const DEFAULT_MESSAGE_ID_DOMAIN: &str = "localhost";
 
-/// Something that can be formatted as an email message
-trait EmailFormat {
+pub trait EmailFormat {
     // Use a writer?
     fn format(&self, out: &mut Vec<u8>);
 }
@@ -332,7 +264,7 @@ impl MessageBuilder {
 
     /// Set `Sender` header. Should be used when providing several `From` mailboxes.
     ///
-    /// Defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.2).
+    /// https://tools.ietf.org/html/rfc5322#section-3.6.2
     ///
     /// Shortcut for `self.header(header::Sender(mbox))`.
     pub fn sender(self, mbox: Mailbox) -> Self {
@@ -341,7 +273,7 @@ impl MessageBuilder {
 
     /// Set or add mailbox to `From` header
     ///
-    /// Defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.2).
+    /// https://tools.ietf.org/html/rfc5322#section-3.6.2
     ///
     /// Shortcut for `self.mailbox(header::From(mbox))`.
     pub fn from(self, mbox: Mailbox) -> Self {
@@ -350,7 +282,7 @@ impl MessageBuilder {
 
     /// Set or add mailbox to `ReplyTo` header
     ///
-    /// Defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.2).
+    /// 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 {
@@ -432,7 +364,7 @@ impl MessageBuilder {
     // TODO: High-level methods for attachments and embedded files
 
     /// Create message from body
-    fn build(self, body: MessageBody) -> Result<Message, EmailError> {
+    fn build(self, body: Body) -> Result<Message, EmailError> {
         // Check for missing required headers
         // https://tools.ietf.org/html/rfc5322#section-3.6
 
@@ -467,43 +399,47 @@ impl MessageBuilder {
         })
     }
 
-    /// Create [`Message`] using a [`Vec<u8>`], [`String`], or [`Body`] body
-    ///
-    /// 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);
+    // In theory having a body is optional
 
-        self.headers.set(body.encoding());
-        self.build(MessageBody::Raw(body.into_vec()))
+    /// Plain ASCII 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();
+
+        if !&body.is_ascii() {
+            return Err(EmailError::NonAsciiChars);
+        }
+
+        self.build(Body::Raw(body))
     }
 
     /// Create message using mime body ([`MultiPart`][self::MultiPart])
     pub fn multipart(self, part: MultiPart) -> Result<Message, EmailError> {
-        self.mime_1_0().build(MessageBody::Mime(Part::Multi(part)))
+        self.mime_1_0().build(Body::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(MessageBody::Mime(Part::Single(part)))
+        self.mime_1_0().build(Body::Mime(Part::Single(part)))
     }
 }
 
 /// Email message which can be formatted
-#[cfg_attr(docsrs, doc(cfg(feature = "builder")))]
 #[derive(Clone, Debug)]
 pub struct Message {
     headers: Headers,
-    body: MessageBody,
+    body: Body,
     envelope: Envelope,
 }
 
 #[derive(Clone, Debug)]
-enum MessageBody {
+enum Body {
     Mime(Part),
-    Raw(Vec<u8>),
+    Raw(String),
 }
 
 impl Message {
@@ -533,12 +469,11 @@ 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 {
-            MessageBody::Mime(p) => p.format(out),
-            MessageBody::Raw(r) => {
+            Body::Mime(p) => p.format(out),
+            Body::Raw(r) => {
                 out.extend_from_slice(b"\r\n");
-                out.extend_from_slice(&r)
+                out.extend(r.as_bytes())
             }
         }
     }
@@ -552,13 +487,11 @@ impl Default for MessageBuilder {
 
 #[cfg(test)]
 mod test {
-    use crate::message::{header, mailbox::Mailbox, Message, MultiPart, SinglePart};
+    use crate::message::{header, mailbox::Mailbox, Message};
 
     #[test]
     fn email_missing_originator() {
-        assert!(Message::builder()
-            .body(String::from("Happy new year!"))
-            .is_err());
+        assert!(Message::builder().body("Happy new year!").is_err());
     }
 
     #[test]
@@ -566,7 +499,7 @@ mod test {
         assert!(Message::builder()
             .from("NoBody <nobody@domain.tld>".parse().unwrap())
             .to("NoBody <nobody@domain.tld>".parse().unwrap())
-            .body(String::from("Happy new year!"))
+            .body("Happy new year!")
             .is_ok());
     }
 
@@ -575,7 +508,7 @@ mod test {
         assert!(Message::builder()
             .from("NoBody <nobody@domain.tld>".parse().unwrap())
             .from("AnyBody <anybody@domain.tld>".parse().unwrap())
-            .body(String::from("Happy new year!"))
+            .body("Happy new year!")
             .is_err());
     }
 
@@ -596,7 +529,7 @@ mod test {
                 vec!["Pony O.P. <pony@domain.tld>".parse().unwrap()].into(),
             ))
             .header(header::Subject("яңа ел белән!".into()))
-            .body(String::from("Happy new year!"))
+            .body("Happy new year!")
             .unwrap();
 
         assert_eq!(
@@ -606,57 +539,9 @@ 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,16 +16,19 @@ pub fn encode(s: &str) -> String {
 }
 
 pub fn decode(s: &str) -> Option<String> {
-    s.strip_prefix("=?utf-8?b?")
-        .and_then(|stripped| stripped.strip_suffix("?="))
-        .map_or_else(
-            || Some(s.into()),
-            |stripped| {
-                let decoded = base64::decode(stripped).ok()?;
-                let decoded = String::from_utf8(decoded).ok()?;
-                Some(decoded)
-            },
-        )
+    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())
+    }
 }
 
 #[cfg(test)]

src/transport/file/error.rs

@@ -1,96 +1,57 @@
 //! Error and result type for file transport
 
-use crate::BoxError;
-use std::{error::Error as StdError, fmt};
-
-/// The Errors that may occur when sending an email over SMTP
-pub struct Error {
-    inner: Box<Inner>,
-}
-
-struct Inner {
-    kind: Kind,
-    source: Option<BoxError>,
-}
-
-impl Error {
-    pub(crate) fn new<E>(kind: Kind, source: Option<E>) -> Error
-    where
-        E: Into<BoxError>,
-    {
-        Error {
-            inner: Box::new(Inner {
-                kind,
-                source: source.map(Into::into),
-            }),
-        }
-    }
-
-    /// Returns true if the error is a file I/O error
-    pub fn is_io(&self) -> bool {
-        matches!(self.inner.kind, Kind::Io)
-    }
-
-    /// Returns true if the error is an envelope serialization or deserialization error
-    #[cfg(feature = "file-transport-envelope")]
-    pub fn is_envelope(&self) -> bool {
-        matches!(self.inner.kind, Kind::Envelope)
-    }
-}
+use self::Error::*;
+use std::{
+    error::Error as StdError,
+    fmt::{self, Display, Formatter},
+    io,
+};
 
+/// An enum of all error kinds.
 #[derive(Debug)]
-pub(crate) enum Kind {
-    /// File I/O error
-    Io,
-    /// Envelope serialization/deserialization error
-    #[cfg(feature = "file-transport-envelope")]
-    Envelope,
+pub enum Error {
+    /// Internal client error
+    Client(&'static str),
+    /// IO error
+    Io(io::Error),
+    /// JSON serialization error
+    JsonSerialization(serde_json::Error),
 }
 
-impl fmt::Debug for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut builder = f.debug_struct("lettre::transport::file::Error");
-
-        builder.field("kind", &self.inner.kind);
-
-        if let Some(ref source) = self.inner.source {
-            builder.field("source", source);
+impl Display for 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),
         }
-
-        builder.finish()
-    }
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self.inner.kind {
-            Kind::Io => f.write_str("response error")?,
-            #[cfg(feature = "file-transport-envelope")]
-            Kind::Envelope => f.write_str("internal client error")?,
-        };
-
-        if let Some(ref e) = self.inner.source {
-            write!(f, ": {}", e)?;
-        }
-
-        Ok(())
     }
 }
 
 impl StdError for Error {
     fn source(&self) -> Option<&(dyn StdError + 'static)> {
-        self.inner.source.as_ref().map(|e| {
-            let r: &(dyn std::error::Error + 'static) = &**e;
-            r
-        })
+        match *self {
+            Io(ref err) => Some(&*err),
+            JsonSerialization(ref err) => Some(&*err),
+            _ => None,
+        }
     }
 }
 
-pub(crate) fn io<E: Into<BoxError>>(e: E) -> Error {
-    Error::new(Kind::Io, Some(e))
+impl From<io::Error> for Error {
+    fn from(err: io::Error) -> Error {
+        Error::Io(err)
+    }
 }
 
-#[cfg(feature = "file-transport-envelope")]
-pub(crate) fn envelope<E: Into<BoxError>>(e: E) -> Error {
-    Error::new(Kind::Envelope, Some(e))
+impl From<serde_json::Error> for Error {
+    fn from(err: serde_json::Error) -> Error {
+        Error::JsonSerialization(err)
+    }
+}
+
+impl From<&'static str> for Error {
+    fn from(string: &'static str) -> Error {
+        Error::Client(string)
+    }
 }

src/transport/file/mod.rs

@@ -1,145 +1,98 @@
 //! The file transport writes the emails to the given directory. The name of the file will be
-//! `message_id.eml`.
+//! `message_id.json`.
 //! 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()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
+//!     .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!"))?;
+//!     .body("Be happy!")
+//!     .unwrap();
 //!
 //! let result = sender.send(&email);
 //! assert!(result.is_ok());
-//! # Ok(())
-//! # }
-//!
-//! # #[cfg(not(all(feature = "file-transport", feature = "builder")))]
-//! # fn main() {}
 //! ```
 //!
-//! ## 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.
+//! ## Async tokio 0.2
 //!
 //! ```rust
-//! # use std::error::Error;
-//! #
-//! # #[cfg(all(feature = "file-transport-envelope", feature = "builder"))]
-//! # fn main() -> Result<(), Box<dyn Error>> {
-//! use lettre::{FileTransport, Message, Transport};
+//! # #[cfg(feature = "tokio02")]
+//! # async fn run() {
 //! use std::env::temp_dir;
+//! use lettre::{Tokio02Transport, Envelope, Message, FileTransport};
 //!
 //! // Write to the local temp directory
-//! let sender = FileTransport::with_envelope(temp_dir());
+//! let sender = FileTransport::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()?)
+//!     .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!"))?;
-//!
-//! 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!"))?;
+//!     .body("Be happy!")
+//!     .unwrap();
 //!
 //! let result = sender.send(email).await;
 //! assert!(result.is_ok());
-//! # Ok(())
 //! # }
 //! ```
 //!
 //! ## Async async-std 1.x
 //!
-//! ```rust,no_run
-//! # use std::error::Error;
-//! #
-//! # #[cfg(all(feature = "async-std1", feature = "file-transport", feature = "builder"))]
-//! # async fn run() -> Result<(), Box<dyn Error>> {
+//! ```rust
+//! # #[cfg(feature = "async-std1")]
+//! # async fn run() {
 //! use std::env::temp_dir;
-//! use lettre::{AsyncTransport, AsyncStd1Executor, Message, AsyncFileTransport};
+//! use lettre::{AsyncStd1Transport, Envelope, Message, FileTransport};
 //!
 //! // Write to the local temp directory
-//! let sender = AsyncFileTransport::<AsyncStd1Executor>::new(temp_dir());
+//! let sender = FileTransport::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()?)
+//!     .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!"))?;
+//!     .body("Be happy!")
+//!     .unwrap();
 //!
 //! let result = sender.send(email).await;
 //! assert!(result.is_ok());
-//! # Ok(())
 //! # }
 //! ```
 //!
 //! ---
 //!
-//! 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
+//! Example result
 //!
 //! ```json
-//! {"forward_path":["hei@domain.tld"],"reverse_path":"nobody@domain.tld"}
+//! {
+//!   "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!"
+//! }
 //! ```
 
 pub use self::error::Error;
-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"))]
+#[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 async_trait::async_trait;
-#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
-use std::marker::PhantomData;
 use std::{
     path::{Path, PathBuf},
     str,
@@ -153,113 +106,51 @@ type Id = String;
 /// Writes the content and the envelope information to a file
 #[derive(Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-#[cfg_attr(docsrs, doc(cfg(feature = "file-transport")))]
 pub struct FileTransport {
     path: PathBuf,
-    #[cfg(feature = "file-transport-envelope")]
-    save_envelope: bool,
-}
-
-/// Asynchronously writes the content and the envelope information to a file
-#[derive(Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-#[cfg_attr(
-    docsrs,
-    doc(cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1")))
-)]
-#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
-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).map_err(error::io)?;
-
-        let json_file = self.path.join(format!("{}.json", email_id));
-        let json = fs::read(&json_file).map_err(error::io)?;
-        let envelope = serde_json::from_slice(&json).map_err(error::envelope)?;
-
-        Ok((envelope, eml))
-    }
-
-    fn path(&self, email_id: &Uuid, extension: &str) -> PathBuf {
-        self.path.join(format!("{}.{}", email_id, extension))
-    }
 }
 
-#[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,
-        }
-    }
+#[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>,
+}
 
-    /// 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,
-        }
-    }
+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));
 
-    /// 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.map_err(error::io)?;
+        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),
+            }),
+        }?;
 
-        let json_file = self.inner.path.join(format!("{}.json", email_id));
-        let json = E::fs_read(&json_file).await.map_err(error::io)?;
-        let envelope = serde_json::from_slice(&json).map_err(error::envelope)?;
-
-        Ok((envelope, eml))
+        Ok((email_id, file, serialized))
     }
 }
 
@@ -270,52 +161,41 @@ impl Transport for FileTransport {
     fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
         use std::fs;
 
-        let email_id = Uuid::new_v4();
-
-        let file = self.path(&email_id, "eml");
-        fs::write(file, email).map_err(error::io)?;
-
-        #[cfg(feature = "file-transport-envelope")]
-        {
-            if self.save_envelope {
-                let file = self.path(&email_id, "json");
-                let buf = serde_json::to_string(&envelope).map_err(error::envelope)?;
-                fs::write(file, buf).map_err(error::io)?;
-            }
-        }
-        // use envelope anyway
-        let _ = envelope;
+        let (email_id, file, serialized) = self.send_raw_impl(envelope, email)?;
 
+        fs::write(file, serialized)?;
         Ok(email_id.to_string())
     }
 }
 
-#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+#[cfg(feature = "async-std1")]
 #[async_trait]
-impl<E> AsyncTransport for AsyncFileTransport<E>
-where
-    E: Executor,
-{
+impl AsyncStd1Transport for FileTransport {
     type Ok = Id;
     type Error = Error;
 
     async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
-        let email_id = Uuid::new_v4();
+        use async_std::fs;
 
-        let file = self.inner.path(&email_id, "eml");
-        E::fs_write(&file, email).await.map_err(error::io)?;
-
-        #[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).map_err(error::envelope)?;
-                E::fs_write(&file, &buf).await.map_err(error::io)?;
-            }
-        }
-        // use envelope anyway
-        let _ = envelope;
+        let (email_id, file, serialized) = self.send_raw_impl(envelope, email)?;
 
+        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

@@ -1,136 +1,25 @@
-//! ## Transports for sending emails
+//! ### Sending Messages
 //!
-//! This module contains `Transport`s for sending emails. A `Transport` implements a high-level API
-//! for sending emails. It automatically manages the underlying resources and doesn't require any
-//! specific knowledge of email protocols in order to be used.
+//! This section explains how to manipulate emails you have created.
+//!
+//! This mailer contains several different transports for your emails. To be sendable, the
+//! emails have to implement `Email`, which is the case for emails created with `lettre::builder`.
 //!
 //! The following transports are available:
 //!
-//! | Module       | Protocol | Sync API              | Async API                  | Description                                             |
-//! | ------------ | -------- | --------------------- | -------------------------- | ------------------------------------------------------- |
-//! | [`smtp`]     | SMTP     | [`SmtpTransport`]     | [`AsyncSmtpTransport`]     | Uses the SMTP protocol to send emails to a relay server |
-//! | [`sendmail`] | Sendmail | [`SendmailTransport`] | [`AsyncSendmailTransport`] | Uses the `sendmail` command to send emails              |
-//! | [`file`]     | File     | [`FileTransport`]     | [`AsyncFileTransport`]     | Saves the email as an `.eml` file                       |
-//! | [`stub`]     | Debug    | [`StubTransport`]     | [`StubTransport`]          | Drops the email - Useful for debugging                  |
-//!
-//! ## Building an email
-//!
-//! Emails can either be built though [`Message`], which is a typed API for constructing emails
-//! (find out more about it by going over the [`message`][crate::message] module),
-//! or via external means.
-//!
-//! [`Message`]s can be sent via [`Transport::send`] or [`AsyncTransport::send`], while messages
-//! built without lettre's [`message`][crate::message] APIs can be sent via [`Transport::send_raw`]
-//! or [`AsyncTransport::send_raw`].
-//!
-//! ## Brief example
-//!
-//! This example shows how to build an email and send it via an SMTP relay server.
-//! It is in no way a complete example, but it shows how to get started with lettre.
-//! More examples can be found by looking at the specific modules, linked in the _Module_ column
-//! of the [table above](#transports-for-sending-emails).
-//!
-//! ```rust,no_run
-//! # use std::error::Error;
-//! #
-//! # #[cfg(all(feature = "builder", feature = "smtp-transport"))]
-//! # fn main() -> Result<(), Box<dyn Error>> {
-//! use lettre::transport::smtp::authentication::Credentials;
-//! use lettre::{Message, SmtpTransport, 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 creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
-//!
-//! // Open a remote connection to the SMTP relay server
-//! let mailer = SmtpTransport::relay("smtp.gmail.com")?
-//!     .credentials(creds)
-//!     .build();
-//!
-//! // Send the email
-//! match mailer.send(&email) {
-//!     Ok(_) => println!("Email sent successfully!"),
-//!     Err(e) => panic!("Could not send email: {:?}", e),
-//! }
-//! # Ok(())
-//! # }
-//! # #[cfg(not(all(feature = "builder", feature = "smtp-transport")))]
-//! # fn main() {}
-//! ```
-//!
-//! [`Message`]: crate::Message
-//! [`file`]: self::file
-//! [`SmtpTransport`]: crate::SmtpTransport
-//! [`AsyncSmtpTransport`]: crate::AsyncSmtpTransport
-//! [`SendmailTransport`]: crate::SendmailTransport
-//! [`AsyncSendmailTransport`]: crate::AsyncSendmailTransport
-//! [`FileTransport`]: crate::FileTransport
-//! [`AsyncFileTransport`]: crate::AsyncFileTransport
-//! [`StubTransport`]: crate::transport::stub::StubTransport
-
-#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
-use async_trait::async_trait;
-
-use crate::Envelope;
-#[cfg(feature = "builder")]
-use crate::Message;
+//! * The `SmtpTransport` uses the SMTP protocol to send the message over the network. It is
+//!   the preferred way of sending emails.
+//! * The `SendmailTransport` uses the sendmail command to send messages. It is an alternative to
+//!   the SMTP transport.
+//! * The `FileTransport` creates a file containing the email content to be sent. It can be used
+//!   for debugging or if you want to keep all sent emails.
+//! * The `StubTransport` is useful for debugging, and only prints the content of the email in the
+//!   logs.
 
 #[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

@@ -1,92 +1,52 @@
 //! Error and result type for sendmail transport
 
-use crate::BoxError;
-use std::{error::Error as StdError, fmt};
-
-/// The Errors that may occur when sending an email over sendmail
-pub struct Error {
-    inner: Box<Inner>,
-}
-
-struct Inner {
-    kind: Kind,
-    source: Option<BoxError>,
-}
-
-impl Error {
-    pub(crate) fn new<E>(kind: Kind, source: Option<E>) -> Error
-    where
-        E: Into<BoxError>,
-    {
-        Error {
-            inner: Box::new(Inner {
-                kind,
-                source: source.map(Into::into),
-            }),
-        }
-    }
-
-    /// Returns true if the error is from client
-    pub fn is_client(&self) -> bool {
-        matches!(self.inner.kind, Kind::Client)
-    }
-
-    /// Returns true if the error comes from the response
-    pub fn is_response(&self) -> bool {
-        matches!(self.inner.kind, Kind::Response)
-    }
-}
+use self::Error::*;
+use std::{
+    error::Error as StdError,
+    fmt::{self, Display, Formatter},
+    io,
+    string::FromUtf8Error,
+};
 
+/// An enum of all error kinds.
 #[derive(Debug)]
-pub(crate) enum Kind {
-    /// Error parsing a response
-    Response,
+pub enum Error {
     /// Internal client error
-    Client,
+    Client(String),
+    /// Error parsing UTF8 in response
+    Utf8Parsing(FromUtf8Error),
+    /// IO error
+    Io(io::Error),
 }
 
-impl fmt::Debug for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut builder = f.debug_struct("lettre::transport::sendmail::Error");
-
-        builder.field("kind", &self.inner.kind);
-
-        if let Some(ref source) = self.inner.source {
-            builder.field("source", source);
+impl Display for Error {
+    fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {
+        match *self {
+            Client(ref err) => err.fmt(fmt),
+            Utf8Parsing(ref err) => err.fmt(fmt),
+            Io(ref err) => err.fmt(fmt),
         }
-
-        builder.finish()
-    }
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self.inner.kind {
-            Kind::Response => f.write_str("response error")?,
-            Kind::Client => f.write_str("internal client error")?,
-        };
-
-        if let Some(ref e) = self.inner.source {
-            write!(f, ": {}", e)?;
-        }
-
-        Ok(())
     }
 }
 
 impl StdError for Error {
     fn source(&self) -> Option<&(dyn StdError + 'static)> {
-        self.inner.source.as_ref().map(|e| {
-            let r: &(dyn std::error::Error + 'static) = &**e;
-            r
-        })
+        match *self {
+            Io(ref err) => Some(&*err),
+            Utf8Parsing(ref err) => Some(&*err),
+            _ => None,
+        }
     }
 }
 
-pub(crate) fn response<E: Into<BoxError>>(e: E) -> Error {
-    Error::new(Kind::Response, Some(e))
+impl From<io::Error> for Error {
+    fn from(err: io::Error) -> Error {
+        Error::Io(err)
+    }
 }
 
-pub(crate) fn client<E: Into<BoxError>>(e: E) -> Error {
-    Error::new(Kind::Client, Some(e))
+impl From<FromUtf8Error> for Error {
+    fn from(err: FromUtf8Error) -> Error {
+        Utf8Parsing(err)
+    }
 }

src/transport/sendmail/mod.rs

@@ -1,150 +1,96 @@
-//! The sendmail transport sends the email using the local `sendmail` command.
+//! The sendmail transport sends the email using the local sendmail command.
 //!
 //! ## Sync example
 //!
 //! ```rust
-//! # use std::error::Error;
-//! #
-//! # #[cfg(all(feature = "sendmail-transport", feature = "builder"))]
-//! # fn main() -> Result<(), Box<dyn Error>> {
-//! use lettre::{Message, SendmailTransport, Transport};
+//! use lettre::{Message, Envelope, Transport, SendmailTransport};
 //!
 //! let email = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
+//!     .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!"))?;
+//!     .body("Be happy!")
+//!     .unwrap();
 //!
 //! 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,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};
+//! ```rust
+//! # #[cfg(feature = "tokio02")]
+//! # async fn run() {
+//! use lettre::{Message, Envelope, Tokio02Transport, SendmailTransport};
 //!
 //! let email = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
+//!     .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!"))?;
+//!     .body("Be happy!")
+//!     .unwrap();
 //!
-//! let sender = AsyncSendmailTransport::<Tokio02Executor>::new();
+//! let sender = SendmailTransport::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,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};
+//!```rust
+//! # #[cfg(feature = "async-std1")]
+//! # async fn run() {
+//! use lettre::{Message, Envelope, AsyncStd1Transport, SendmailTransport};
 //!
 //! let email = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
+//!     .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!"))?;
+//!     .body("Be happy!")
+//!     .unwrap();
 //!
-//! let sender = AsyncSendmailTransport::<AsyncStd1Executor>::new();
+//! let sender = SendmailTransport::new();
 //! let result = sender.send(email).await;
 //! assert!(result.is_ok());
-//! # Ok(())
 //! # }
 //! ```
 
 pub use self::error::Error;
 #[cfg(feature = "async-std1")]
-use crate::AsyncStd1Executor;
+use crate::AsyncStd1Transport;
 #[cfg(feature = "tokio02")]
-use crate::Tokio02Executor;
-#[cfg(feature = "tokio1")]
-use crate::Tokio1Executor;
-use crate::{address::Envelope, Transport};
-#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
-use crate::{AsyncTransport, Executor};
-#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
+use crate::Tokio02Transport;
+use crate::{Envelope, Transport};
+#[cfg(any(feature = "async-std1", feature = "tokio02"))]
 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::Write,
+    io::prelude::*,
     process::{Command, Stdio},
 };
 
 mod error;
 
-const DEFAULT_SENDMAIL: &str = "/usr/sbin/sendmail";
+const DEFAUT_SENDMAIL: &str = "/usr/sbin/sendmail";
 
-/// Sends emails using the `sendmail` command
-#[derive(Debug, Clone)]
+/// Sends an email using the `sendmail` command
+#[derive(Debug, Default)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-#[cfg_attr(docsrs, doc(cfg(feature = "sendmail-transport")))]
 pub struct SendmailTransport {
     command: OsString,
 }
 
-/// Asynchronously sends emails using the `sendmail` command
-#[derive(Debug, Clone)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-#[cfg(any(feature = "async-std1", feature = "tokio02", feature = "tokio1"))]
-#[cfg_attr(
-    docsrs,
-    doc(cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1")))
-)]
-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 {
         SendmailTransport {
-            command: DEFAULT_SENDMAIL.into(),
+            command: DEFAUT_SENDMAIL.into(),
         }
     }
 
@@ -157,110 +103,29 @@ impl SendmailTransport {
 
     fn command(&self, envelope: &Envelope) -> Command {
         let mut c = Command::new(&self.command);
-        c.arg("-i");
-        if let Some(from) = envelope.from() {
-            c.arg("-f").arg(from);
-        }
-        c.arg("--")
+        c.arg("-i")
+            .arg("-f")
+            .arg(envelope.from().map(|f| f.as_ref()).unwrap_or("\"\""))
             .args(envelope.to())
             .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped());
+            .stdout(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.inner.command);
+        let mut c = Command::new(&self.command);
         c.kill_on_drop(true);
-        c.arg("-i");
-        if let Some(from) = envelope.from() {
-            c.arg("-f").arg(from);
-        }
-        c.arg("--")
+        c.arg("-i")
+            .arg("-f")
+            .arg(envelope.from().map(|f| f.as_ref()).unwrap_or("\"\""))
             .args(envelope.to())
             .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped());
+            .stdout(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 {
@@ -269,60 +134,50 @@ impl Transport for SendmailTransport {
 
     fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
         // Spawn the sendmail command
-        let mut process = self.command(envelope).spawn().map_err(error::client)?;
+        let mut process = self.command(envelope).spawn()?;
 
-        process
-            .stdin
-            .as_mut()
-            .unwrap()
-            .write_all(email)
-            .map_err(error::client)?;
-        let output = process.wait_with_output().map_err(error::client)?;
+        process.stdin.as_mut().unwrap().write_all(email)?;
+        let output = process.wait_with_output()?;
 
         if output.status.success() {
             Ok(())
         } else {
-            let stderr = String::from_utf8(output.stderr).map_err(error::response)?;
-            Err(error::client(stderr))
+            Err(error::Error::Client(String::from_utf8(output.stderr)?))
         }
     }
 }
 
 #[cfg(feature = "async-std1")]
 #[async_trait]
-impl AsyncTransport for AsyncSendmailTransport<AsyncStd1Executor> {
+impl AsyncStd1Transport for SendmailTransport {
     type Ok = ();
     type Error = Error;
 
     async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
-        use async_std::io::prelude::WriteExt;
+        let mut command = self.command(envelope);
+        let email = email.to_vec();
 
-        let mut command = self.async_std_command(envelope);
+        // 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()?;
 
-        // Spawn the sendmail command
-        let mut process = command.spawn().map_err(error::client)?;
-
-        process
-            .stdin
-            .as_mut()
-            .unwrap()
-            .write_all(&email)
-            .await
-            .map_err(error::client)?;
-        let output = process.output().await.map_err(error::client)?;
+            process.stdin.as_mut().unwrap().write_all(&email)?;
+            process.wait_with_output()
+        })
+        .await?;
 
         if output.status.success() {
             Ok(())
         } else {
-            let stderr = String::from_utf8(output.stderr).map_err(error::response)?;
-            Err(error::client(stderr))
+            Err(Error::Client(String::from_utf8(output.stderr)?))
         }
     }
 }
 
 #[cfg(feature = "tokio02")]
 #[async_trait]
-impl AsyncTransport for AsyncSendmailTransport<Tokio02Executor> {
+impl Tokio02Transport for SendmailTransport {
     type Ok = ();
     type Error = Error;
 
@@ -332,54 +187,15 @@ impl AsyncTransport for AsyncSendmailTransport<Tokio02Executor> {
         let mut command = self.tokio02_command(envelope);
 
         // Spawn the sendmail command
-        let mut process = command.spawn().map_err(error::client)?;
+        let mut process = command.spawn()?;
 
-        process
-            .stdin
-            .as_mut()
-            .unwrap()
-            .write_all(&email)
-            .await
-            .map_err(error::client)?;
-        let output = process.wait_with_output().await.map_err(error::client)?;
+        process.stdin.as_mut().unwrap().write_all(&email).await?;
+        let output = process.wait_with_output().await?;
 
         if output.status.success() {
             Ok(())
         } else {
-            let stderr = String::from_utf8(output.stderr).map_err(error::response)?;
-            Err(error::client(stderr))
-        }
-    }
-}
-
-#[cfg(feature = "tokio1")]
-#[async_trait]
-impl AsyncTransport for AsyncSendmailTransport<Tokio1Executor> {
-    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().map_err(error::client)?;
-
-        process
-            .stdin
-            .as_mut()
-            .unwrap()
-            .write_all(&email)
-            .await
-            .map_err(error::client)?;
-        let output = process.wait_with_output().await.map_err(error::client)?;
-
-        if output.status.success() {
-            Ok(())
-        } else {
-            let stderr = String::from_utf8(output.stderr).map_err(error::response)?;
-            Err(error::client(stderr))
+            Err(Error::Client(String::from_utf8(output.stderr)?))
         }
     }
 }

src/transport/smtp/async_transport.rs

@@ -1,34 +1,21 @@
-use std::fmt::{self, Debug};
-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,
 };
-#[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};
+use crate::{Envelope, Tokio02Transport};
 
-/// Asynchronously sends emails using the SMTP protocol
-#[cfg_attr(
-    docsrs,
-    doc(cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1")))
-)]
-pub struct AsyncSmtpTransport<E> {
+#[allow(missing_debug_implementations)]
+#[derive(Clone)]
+pub struct AsyncSmtpTransport<C> {
     // TODO: pool
-    inner: AsyncSmtpClient<E>,
+    inner: AsyncSmtpClient<C>,
 }
 
-#[cfg(feature = "tokio02")]
 #[async_trait]
-impl AsyncTransport for AsyncSmtpTransport<Tokio02Executor> {
+impl Tokio02Transport for AsyncSmtpTransport<Tokio02Connector> {
     type Ok = Response;
     type Error = Error;
 
@@ -44,74 +31,21 @@ impl AsyncTransport for AsyncSmtpTransport<Tokio02Executor> {
     }
 }
 
-#[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>
+impl<C> AsyncSmtpTransport<C>
 where
-    E: Executor,
+    C: AsyncSmtpConnector,
 {
-    /// Simple and secure transport, using TLS connections to communicate with the SMTP server
+    /// Simple and secure transport, using TLS connections to comunicate 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",
-        feature = "tokio1-native-tls",
-        feature = "tokio1-rustls-tls",
-        feature = "async-std1-native-tls",
-        feature = "async-std1-rustls-tls"
-    ))]
-    #[cfg_attr(
-        docsrs,
-        doc(cfg(any(
-            feature = "tokio02-native-tls",
-            feature = "tokio02-rustls-tls",
-            feature = "tokio1-native-tls",
-            feature = "tokio1-rustls-tls",
-            feature = "async-std1-rustls-tls"
-        )))
-    )]
+    #[cfg(any(feature = "tokio02-native-tls", feature = "tokio02-rustls-tls"))]
     pub fn relay(relay: &str) -> Result<AsyncSmtpTransportBuilder, Error> {
-        use super::{Tls, TlsParameters, SUBMISSIONS_PORT};
+        use super::{TlsParameters, SUBMISSIONS_PORT};
 
-        let tls_parameters = TlsParameters::new(relay.into())?;
+        let tls_parameters = TlsParameters::new_tokio02(relay.into())?;
 
         Ok(Self::builder_dangerous(relay)
             .port(SUBMISSIONS_PORT)
@@ -129,26 +63,9 @@ where
     ///
     /// An error is returned if the connection can't be upgraded. No credentials
     /// or emails will be sent to the server, protecting from downgrade attacks.
-    #[cfg(any(
-        feature = "tokio02-native-tls",
-        feature = "tokio02-rustls-tls",
-        feature = "tokio1-native-tls",
-        feature = "tokio1-rustls-tls",
-        feature = "async-std1-native-tls",
-        feature = "async-std1-rustls-tls"
-    ))]
-    #[cfg_attr(
-        docsrs,
-        doc(cfg(any(
-            feature = "tokio02-native-tls",
-            feature = "tokio02-rustls-tls",
-            feature = "tokio1-native-tls",
-            feature = "tokio1-rustls-tls",
-            feature = "async-std1-rustls-tls"
-        )))
-    )]
+    #[cfg(any(feature = "tokio02-native-tls", feature = "tokio02-rustls-tls"))]
     pub fn starttls_relay(relay: &str) -> Result<AsyncSmtpTransportBuilder, Error> {
-        use super::{Tls, TlsParameters, SUBMISSION_PORT};
+        use super::{TlsParameters, SUBMISSION_PORT};
 
         let tls_parameters = TlsParameters::new(relay.into())?;
 
@@ -160,7 +77,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<E> {
+    pub fn unencrypted_localhost() -> AsyncSmtpTransport<C> {
         Self::builder_dangerous("localhost").build()
     }
 
@@ -176,40 +93,15 @@ where
     /// [`AsyncSmtpTransport::starttls_relay`](#method.starttls_relay) instead,
     /// if possible.
     pub fn builder_dangerous<T: Into<String>>(server: T) -> AsyncSmtpTransportBuilder {
-        let new = SmtpInfo {
-            server: server.into(),
-            ..Default::default()
-        };
+        let mut new = SmtpInfo::default();
+        new.server = server.into();
         AsyncSmtpTransportBuilder { info: new }
     }
 }
 
-impl<E> Debug for AsyncSmtpTransport<E> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut builder = f.debug_struct("AsyncSmtpTransport");
-        builder.field("inner", &self.inner);
-        builder.finish()
-    }
-}
-
-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`].
-#[derive(Debug, Clone)]
-#[cfg_attr(
-    docsrs,
-    doc(cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1")))
-)]
+/// Contains client configuration
+#[allow(missing_debug_implementations)]
+#[derive(Clone)]
 pub struct AsyncSmtpTransportBuilder {
     info: SmtpInfo,
 }
@@ -241,57 +133,42 @@ impl AsyncSmtpTransportBuilder {
     }
 
     /// Set the TLS settings to use
-    #[cfg(any(
-        feature = "tokio02-native-tls",
-        feature = "tokio02-rustls-tls",
-        feature = "tokio1-native-tls",
-        feature = "tokio1-rustls-tls",
-        feature = "async-std1-native-tls",
-        feature = "async-std1-rustls-tls"
-    ))]
-    #[cfg_attr(
-        docsrs,
-        doc(cfg(any(
-            feature = "tokio02-native-tls",
-            feature = "tokio02-rustls-tls",
-            feature = "tokio1-native-tls",
-            feature = "tokio1-rustls-tls",
-            feature = "async-std1-rustls-tls"
-        )))
-    )]
-    pub fn tls(mut self, tls: super::Tls) -> Self {
+    #[cfg(any(feature = "tokio02-native-tls", feature = "tokio02-rustls-tls"))]
+    pub fn tls(mut self, tls: Tls) -> Self {
         self.info.tls = tls;
         self
     }
 
-    /// Build the transport
-    pub fn build<E>(self) -> AsyncSmtpTransport<E>
+    /// Build the transport (with default pool if enabled)
+    pub fn build<C>(self) -> AsyncSmtpTransport<C>
     where
-        E: Executor,
+        C: AsyncSmtpConnector,
     {
+        let connector = Default::default();
         let client = AsyncSmtpClient {
+            connector,
             info: self.info,
-            marker_: PhantomData,
         };
         AsyncSmtpTransport { inner: client }
     }
 }
 
 /// Build client
-pub struct AsyncSmtpClient<E> {
+#[derive(Clone)]
+pub struct AsyncSmtpClient<C> {
+    connector: C,
     info: SmtpInfo,
-    marker_: PhantomData<E>,
 }
 
-impl<E> AsyncSmtpClient<E>
+impl<C> AsyncSmtpClient<C>
 where
-    E: Executor,
+    C: AsyncSmtpConnector,
 {
     /// Creates a new connection directly usable to send emails
     ///
     /// Handles encryption and authentication
     pub async fn connection(&self) -> Result<AsyncSmtpConnection, Error> {
-        let mut conn = E::connect(
+        let mut conn = C::connect(
             &self.info.server,
             self.info.port,
             &self.info.hello_name,
@@ -306,22 +183,61 @@ where
     }
 }
 
-impl<E> Debug for AsyncSmtpClient<E> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut builder = f.debug_struct("AsyncSmtpClient");
-        builder.field("info", &self.info);
-        builder.finish()
+#[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?;
+            }
+            _ => (),
+        }
+
+        Ok(conn)
     }
 }
 
-impl<E> AsyncSmtpClient<E>
-where
-    E: Executor,
-{
-    fn clone(&self) -> Self {
-        Self {
-            info: self.info.clone(),
-            marker_: PhantomData,
-        }
-    }
+mod private {
+    use super::*;
+
+    pub trait Sealed {}
+
+    #[cfg(feature = "tokio02")]
+    impl Sealed for Tokio02Connector {}
 }

src/transport/smtp/authentication.rs

@@ -1,14 +1,33 @@
 //! Provides limited SASL authentication mechanisms
 
-use crate::transport::smtp::error::{self, Error};
-use std::fmt::{self, Debug, Display, Formatter};
+use crate::transport::smtp::error::Error;
+use std::fmt::{self, Display, Formatter};
 
 /// Accepted authentication mechanisms
 /// 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)]
+#[derive(PartialEq, Eq, Clone, Hash, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Credentials {
     authentication_identity: String,
@@ -25,41 +44,24 @@ 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())
-    }
-}
-
-impl Debug for Credentials {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Credentials").finish()
-    }
-}
-
 /// 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, defined in
-    /// [RFC 4616](https://tools.ietf.org/html/rfc4616)
+    /// PLAIN authentication mechanism
+    /// RFC 4616: https://tools.ietf.org/html/rfc4616
     Plain,
     /// LOGIN authentication mechanism
     /// Obsolete but needed for some providers (like office365)
-    ///
-    /// Defined in [draft-murchison-sasl-login-00](https://www.ietf.org/archive/id/draft-murchison-sasl-login-00.txt).
+    /// https://www.ietf.org/archive/id/draft-murchison-sasl-login-00.txt
     Login,
-    /// Non-standard XOAUTH2 mechanism, defined in
-    /// [xoauth2-protocol](https://developers.google.com/gmail/imap/xoauth2-protocol)
+    /// Non-standard XOAUTH2 mechanism
+    /// 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",
@@ -86,15 +88,15 @@ impl Mechanism {
     ) -> Result<String, Error> {
         match self {
             Mechanism::Plain => match challenge {
-                Some(_) => Err(error::client("This mechanism does not expect a challenge")),
+                Some(_) => Err(Error::Client("This mechanism does not expect a challenge")),
                 None => Ok(format!(
                     "\u{0}{}\u{0}{}",
                     credentials.authentication_identity, credentials.secret
                 )),
             },
             Mechanism::Login => {
-                let decoded_challenge = challenge
-                    .ok_or_else(|| error::client("This mechanism does expect a challenge"))?;
+                let decoded_challenge =
+                    challenge.ok_or(Error::Client("This mechanism does expect a challenge"))?;
 
                 if vec!["User Name", "Username:", "Username"].contains(&decoded_challenge) {
                     return Ok(credentials.authentication_identity.to_string());
@@ -104,10 +106,10 @@ impl Mechanism {
                     return Ok(credentials.secret.to_string());
                 }
 
-                Err(error::client("Unrecognized challenge"))
+                Err(Error::Client("Unrecognized challenge"))
             }
             Mechanism::Xoauth2 => match challenge {
-                Some(_) => Err(error::client("This mechanism does not expect a challenge")),
+                Some(_) => Err(Error::Client("This mechanism does not expect a challenge")),
                 None => Ok(format!(
                     "user={}\x01auth=Bearer {}\x01\x01",
                     credentials.authentication_identity, credentials.secret
@@ -166,12 +168,4 @@ 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

@@ -1,17 +1,18 @@
+use std::{fmt::Display, io};
+
+use futures_util::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+
 use super::{AsyncNetworkStream, ClientCodec, TlsParameters};
 use crate::{
     transport::smtp::{
         authentication::{Credentials, Mechanism},
         commands::*,
-        error,
         error::Error,
         extension::{ClientId, Extension, MailBodyParameter, MailParameter, ServerInfo},
         response::{parse_response, Response},
     },
     Envelope,
 };
-use futures_util::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
-use std::fmt::Display;
 
 #[cfg(feature = "tracing")]
 use super::escape_crlf;
@@ -44,10 +45,11 @@ 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,
@@ -58,34 +60,6 @@ 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,
@@ -111,32 +85,9 @@ impl AsyncSmtpConnection {
         // Mail
         let mut mail_options = vec![];
 
-        // 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",
-                ));
-            }
+        if self.server_info().supports_feature(Extension::EightBitMime) {
             mail_options.push(MailParameter::Body(MailBodyParameter::EightBitMime));
         }
-
         try_smtp!(
             self.command(Mail::new(envelope.from().cloned(), mail_options))
                 .await,
@@ -185,7 +136,7 @@ impl AsyncSmtpConnection {
             try_smtp!(self.ehlo(hello_name).await, self);
             Ok(())
         } else {
-            Err(error::client("STARTTLS is not supported on this server"))
+            Err(Error::Client("STARTTLS is not supported on this server"))
         }
     }
 
@@ -232,10 +183,12 @@ impl AsyncSmtpConnection {
         let mechanism = self
             .server_info
             .get_auth_mechanism(mechanisms)
-            .ok_or_else(|| error::client("No compatible authentication mechanism was found"))?;
+            .ok_or(Error::Client(
+                "No compatible authentication mechanism was found",
+            ))?;
 
         // Limit challenges to avoid blocking
-        let mut challenges: u8 = 10;
+        let mut challenges = 10;
         let mut response = self
             .command(Auth::new(mechanism, credentials.clone(), None)?)
             .await?;
@@ -254,7 +207,7 @@ impl AsyncSmtpConnection {
         }
 
         if challenges == 0 {
-            Err(error::response("Unexpected number of challenges"))
+            Err(Error::ResponseParsing("Unexpected number of challenges"))
         } else {
             Ok(response)
         }
@@ -278,16 +231,8 @@ impl AsyncSmtpConnection {
 
     /// Writes a string to the server
     async fn write(&mut self, string: &[u8]) -> Result<(), Error> {
-        self.stream
-            .get_mut()
-            .write_all(string)
-            .await
-            .map_err(error::network)?;
-        self.stream
-            .get_mut()
-            .flush()
-            .await
-            .map_err(error::network)?;
+        self.stream.get_mut().write_all(string).await?;
+        self.stream.get_mut().flush().await?;
 
         #[cfg(feature = "tracing")]
         tracing::debug!("Wrote: {}", escape_crlf(&String::from_utf8_lossy(string)));
@@ -298,33 +243,27 @@ impl AsyncSmtpConnection {
     pub async fn read_response(&mut self) -> Result<Response, Error> {
         let mut buffer = String::with_capacity(100);
 
-        while self
-            .stream
-            .read_line(&mut buffer)
-            .await
-            .map_err(error::network)?
-            > 0
-        {
+        while self.stream.read_line(&mut buffer).await? > 0 {
             #[cfg(feature = "tracing")]
             tracing::debug!("<< {}", escape_crlf(&buffer));
             match parse_response(&buffer) {
                 Ok((_remaining, response)) => {
-                    return if response.is_positive() {
-                        Ok(response)
-                    } else {
-                        Err(error::code(response.code))
+                    if response.is_positive() {
+                        return Ok(response);
                     }
+
+                    return Err(response.into());
                 }
                 Err(nom::Err::Failure(e)) => {
-                    return Err(error::response(e.to_string()));
+                    return Err(Error::Parsing(e.1));
                 }
                 Err(nom::Err::Incomplete(_)) => { /* read more */ }
                 Err(nom::Err::Error(e)) => {
-                    return Err(error::response(e.to_string()));
+                    return Err(Error::Parsing(e.1));
                 }
             }
         }
 
-        Err(error::response("incomplete response"))
+        Err(io::Error::new(io::ErrorKind::Other, "incomplete").into())
     }
 }

src/transport/smtp/client/async_net.rs

@@ -1,56 +1,27 @@
-#[cfg(any(
-    feature = "tokio02-rustls-tls",
-    feature = "tokio1-rustls-tls",
-    feature = "async-std1-rustls-tls"
-))]
+#[cfg(feature = "tokio02-rustls-tls")]
 use std::sync::Arc;
 use std::{
-    net::SocketAddr,
+    net::{Shutdown, SocketAddr},
     pin::Pin,
     task::{Context, Poll},
 };
 
-use futures_io::{
-    AsyncRead as FuturesAsyncRead, AsyncWrite as FuturesAsyncWrite, Error as IoError, ErrorKind,
-    Result as IoResult,
-};
+use futures_io::{Error as IoError, ErrorKind, Result as IoResult};
 #[cfg(feature = "tokio02")]
-use tokio02_crate::io::{AsyncRead as _, AsyncWrite as _};
-#[cfg(feature = "tokio1")]
-use tokio1_crate::io::{AsyncRead as _, AsyncWrite as _, ReadBuf as Tokio1ReadBuf};
-
-#[cfg(feature = "async-std1")]
-use async_std::net::TcpStream as AsyncStd1TcpStream;
+use tokio02_crate::io::{AsyncRead, AsyncWrite};
 #[cfg(feature = "tokio02")]
-use tokio02_crate::net::TcpStream as Tokio02TcpStream;
-#[cfg(feature = "tokio1")]
-use tokio1_crate::net::TcpStream as Tokio1TcpStream;
+use tokio02_crate::net::TcpStream;
 
-#[cfg(feature = "async-std1-native-tls")]
-use async_native_tls::TlsStream as AsyncStd1TlsStream;
 #[cfg(feature = "tokio02-native-tls")]
-use tokio02_native_tls_crate::TlsStream as Tokio02TlsStream;
-#[cfg(feature = "tokio1-native-tls")]
-use tokio1_native_tls_crate::TlsStream as Tokio1TlsStream;
+use tokio02_native_tls_crate::TlsStream;
 
-#[cfg(feature = "async-std1-rustls-tls")]
-use async_rustls::client::TlsStream as AsyncStd1RustlsTlsStream;
 #[cfg(feature = "tokio02-rustls-tls")]
-use tokio02_rustls::client::TlsStream as Tokio02RustlsTlsStream;
-#[cfg(feature = "tokio1-rustls-tls")]
-use tokio1_rustls::client::TlsStream as Tokio1RustlsTlsStream;
+use tokio02_rustls::client::TlsStream as RustlsTlsStream;
 
-#[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"
-))]
+#[cfg(any(feature = "tokio02-native-tls", feature = "tokio02-rustls-tls"))]
 use super::InnerTlsParameters;
 use super::TlsParameters;
-use crate::transport::smtp::{error, Error};
+use crate::transport::smtp::Error;
 
 /// A network stream
 pub struct AsyncNetworkStream {
@@ -58,38 +29,17 @@ 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 Tokio 0.2 TCP stream
+    /// Plain TCP stream
     #[cfg(feature = "tokio02")]
-    Tokio02Tcp(Tokio02TcpStream),
-    /// Encrypted Tokio 0.2 TCP stream
+    Tokio02Tcp(TcpStream),
+    /// Encrypted TCP stream
     #[cfg(feature = "tokio02-native-tls")]
-    Tokio02NativeTls(Tokio02TlsStream<Tokio02TcpStream>),
-    /// Encrypted Tokio 0.2 TCP stream
+    Tokio02NativeTls(TlsStream<TcpStream>),
+    /// Encrypted TCP stream
     #[cfg(feature = "tokio02-rustls-tls")]
-    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>),
+    Tokio02RustlsTls(Box<RustlsTlsStream<TcpStream>>),
     /// Can't be built
     None,
 }
@@ -97,7 +47,7 @@ enum InnerAsyncNetworkStream {
 impl AsyncNetworkStream {
     fn new(inner: InnerAsyncNetworkStream) -> Self {
         if let InnerAsyncNetworkStream::None = inner {
-            debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
+            debug_assert!(false, "InnerAsyncNetworkStream::None should never be built");
         }
 
         AsyncNetworkStream { inner }
@@ -114,39 +64,41 @@ 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 must never be built");
+                debug_assert!(false, "InnerAsyncNetworkStream::None should never be built");
                 Err(IoError::new(
                     ErrorKind::Other,
-                    "InnerAsyncNetworkStream::None must never be built",
+                    "InnerAsyncNetworkStream::None should 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 = Tokio02TcpStream::connect((hostname, port))
-            .await
-            .map_err(error::connection)?;
+        let tcp_stream = TcpStream::connect((hostname, port)).await?;
 
         let mut stream = AsyncNetworkStream::new(InnerAsyncNetworkStream::Tokio02Tcp(tcp_stream));
         if let Some(tls_parameters) = tls_parameters {
@@ -155,46 +107,9 @@ 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
-            .map_err(error::connection)?;
-
-        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
-            .map_err(error::connection)?;
-
-        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(all(
-                feature = "tokio02",
-                not(any(feature = "tokio02-native-tls", feature = "tokio02-rustls-tls"))
-            ))]
+            #[cfg(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");
@@ -209,55 +124,7 @@ impl AsyncNetworkStream {
                     _ => unreachable!(),
                 };
 
-                self.inner = Self::upgrade_tokio02_tls(tcp_stream, tls_parameters)
-                    .await
-                    .map_err(error::connection)?;
-                Ok(())
-            }
-            #[cfg(all(
-                feature = "tokio1",
-                not(any(feature = "tokio1-native-tls", feature = "tokio1-rustls-tls"))
-            ))]
-            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
-                    .map_err(error::connection)?;
-                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
-                    .map_err(error::connection)?;
+                self.inner = Self::upgrade_tokio02_tls(tcp_stream, tls_parameters).await?;
                 Ok(())
             }
             _ => Ok(()),
@@ -267,7 +134,7 @@ impl AsyncNetworkStream {
     #[allow(unused_variables)]
     #[cfg(any(feature = "tokio02-native-tls", feature = "tokio02-rustls-tls"))]
     async fn upgrade_tokio02_tls(
-        tcp_stream: Tokio02TcpStream,
+        tcp_stream: TcpStream,
         mut tls_parameters: TlsParameters,
     ) -> Result<InnerAsyncNetworkStream, Error> {
         let domain = std::mem::take(&mut tls_parameters.domain);
@@ -283,10 +150,7 @@ impl AsyncNetworkStream {
                     use tokio02_native_tls_crate::TlsConnector;
 
                     let connector = TlsConnector::from(connector);
-                    let stream = connector
-                        .connect(&domain, tcp_stream)
-                        .await
-                        .map_err(error::connection)?;
+                    let stream = connector.connect(&domain, tcp_stream).await?;
                     Ok(InnerAsyncNetworkStream::Tokio02NativeTls(stream))
                 };
             }
@@ -299,116 +163,11 @@ impl AsyncNetworkStream {
                 return {
                     use tokio02_rustls::{webpki::DNSNameRef, TlsConnector};
 
-                    let domain =
-                        DNSNameRef::try_from_ascii_str(&domain).map_err(error::connection)?;
+                    let domain = DNSNameRef::try_from_ascii_str(&domain)?;
 
                     let connector = TlsConnector::from(Arc::new(config));
-                    let stream = connector
-                        .connect(domain, tcp_stream)
-                        .await
-                        .map_err(error::connection)?;
-                    Ok(InnerAsyncNetworkStream::Tokio02RustlsTls(stream))
-                };
-            }
-        }
-    }
-
-    #[allow(unused_variables)]
-    #[cfg(any(feature = "tokio1-native-tls", feature = "tokio1-rustls-tls"))]
-    async fn upgrade_tokio1_tls(
-        tcp_stream: Tokio1TcpStream,
-        mut tls_parameters: TlsParameters,
-    ) -> Result<InnerAsyncNetworkStream, Error> {
-        let domain = std::mem::take(&mut tls_parameters.domain);
-
-        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
-                        .map_err(error::connection)?;
-                    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).map_err(error::connection)?;
-
-                    let connector = TlsConnector::from(Arc::new(config));
-                    let stream = connector
-                        .connect(domain, tcp_stream)
-                        .await
-                        .map_err(error::connection)?;
-                    Ok(InnerAsyncNetworkStream::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).map_err(error::connection)?;
-
-                    let connector = TlsConnector::from(Arc::new(config));
-                    let stream = connector
-                        .connect(domain, tcp_stream)
-                        .await
-                        .map_err(error::connection)?;
-                    Ok(InnerAsyncNetworkStream::AsyncStd1RustlsTls(stream))
+                    let stream = connector.connect(domain, tcp_stream).await?;
+                    Ok(InnerAsyncNetworkStream::Tokio02RustlsTls(Box::new(stream)))
                 };
             }
         }
@@ -422,27 +181,15 @@ 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 FuturesAsyncRead for AsyncNetworkStream {
+impl futures_io::AsyncRead 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 {
@@ -452,57 +199,16 @@ impl FuturesAsyncRead 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 must never be built");
+                debug_assert!(false, "InnerAsyncNetworkStream::None should never be built");
                 Poll::Ready(Ok(0))
             }
         }
     }
 }
 
-impl FuturesAsyncWrite for AsyncNetworkStream {
-    fn poll_write(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<IoResult<usize>> {
+impl futures_io::AsyncWrite 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),
@@ -510,30 +216,14 @@ impl FuturesAsyncWrite 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 must never be built");
+                debug_assert!(false, "InnerAsyncNetworkStream::None should 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),
@@ -541,49 +231,14 @@ impl FuturesAsyncWrite 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 must never be built");
+                debug_assert!(false, "InnerAsyncNetworkStream::None should never be built");
                 Poll::Ready(Ok(()))
             }
         }
     }
 
-    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(()))
-            }
-        }
+    fn poll_close(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<IoResult<()>> {
+        Poll::Ready(self.shutdown(Shutdown::Write))
     }
 }

src/transport/smtp/client/connection.rs

@@ -7,15 +7,14 @@ use std::{
 
 use super::{ClientCodec, NetworkStream, TlsParameters};
 use crate::{
-    address::Envelope,
     transport::smtp::{
         authentication::{Credentials, Mechanism},
         commands::*,
-        error,
         error::Error,
         extension::{ClientId, Extension, MailBodyParameter, MailParameter, ServerInfo},
         response::{parse_response, Response},
     },
+    Envelope,
 };
 
 #[cfg(feature = "tracing")]
@@ -67,7 +66,7 @@ impl SmtpConnection {
             panic: false,
             server_info: ServerInfo::default(),
         };
-        conn.set_timeout(timeout).map_err(error::network)?;
+        conn.set_timeout(timeout)?;
         // TODO log
         let _response = conn.read_response()?;
 
@@ -83,32 +82,9 @@ impl SmtpConnection {
         // Mail
         let mut mail_options = vec![];
 
-        // 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",
-                ));
-            }
+        if self.server_info().supports_feature(Extension::EightBitMime) {
             mail_options.push(MailParameter::Body(MailBodyParameter::EightBitMime));
         }
-
         try_smtp!(
             self.command(Mail::new(envelope.from().cloned(), mail_options)),
             self
@@ -157,7 +133,7 @@ impl SmtpConnection {
             // when a TLS library is enabled
             unreachable!("TLS support required but not supported");
         } else {
-            Err(error::client("STARTTLS is not supported on this server"))
+            Err(Error::Client("STARTTLS is not supported on this server"))
         }
     }
 
@@ -210,7 +186,9 @@ impl SmtpConnection {
         let mechanism = self
             .server_info
             .get_auth_mechanism(mechanisms)
-            .ok_or_else(|| error::client("No compatible authentication mechanism was found"))?;
+            .ok_or(Error::Client(
+                "No compatible authentication mechanism was found",
+            ))?;
 
         // Limit challenges to avoid blocking
         let mut challenges = 10;
@@ -229,7 +207,7 @@ impl SmtpConnection {
         }
 
         if challenges == 0 {
-            Err(error::response("Unexpected number of challenges"))
+            Err(Error::ResponseParsing("Unexpected number of challenges"))
         } else {
             Ok(response)
         }
@@ -253,11 +231,8 @@ impl SmtpConnection {
 
     /// Writes a string to the server
     fn write(&mut self, string: &[u8]) -> Result<(), Error> {
-        self.stream
-            .get_mut()
-            .write_all(string)
-            .map_err(error::network)?;
-        self.stream.get_mut().flush().map_err(error::network)?;
+        self.stream.get_mut().write_all(string)?;
+        self.stream.get_mut().flush()?;
 
         #[cfg(feature = "tracing")]
         tracing::debug!("Wrote: {}", escape_crlf(&String::from_utf8_lossy(string)));
@@ -268,27 +243,27 @@ impl SmtpConnection {
     pub fn read_response(&mut self) -> Result<Response, Error> {
         let mut buffer = String::with_capacity(100);
 
-        while self.stream.read_line(&mut buffer).map_err(error::network)? > 0 {
+        while self.stream.read_line(&mut buffer)? > 0 {
             #[cfg(feature = "tracing")]
             tracing::debug!("<< {}", escape_crlf(&buffer));
             match parse_response(&buffer) {
                 Ok((_remaining, response)) => {
-                    return if response.is_positive() {
-                        Ok(response)
-                    } else {
-                        Err(error::code(response.code))
-                    };
+                    if response.is_positive() {
+                        return Ok(response);
+                    }
+
+                    return Err(response.into());
                 }
                 Err(nom::Err::Failure(e)) => {
-                    return Err(error::response(e.to_string()));
+                    return Err(Error::Parsing(e.1));
                 }
                 Err(nom::Err::Incomplete(_)) => { /* read more */ }
                 Err(nom::Err::Error(e)) => {
-                    return Err(error::response(e.to_string()));
+                    return Err(Error::Parsing(e.1));
                 }
             }
         }
 
-        Err(error::response("incomplete response"))
+        Err(io::Error::new(io::ErrorKind::Other, "incomplete").into())
     }
 }

src/transport/smtp/client/mod.rs

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

src/transport/smtp/client/net.rs

@@ -15,7 +15,7 @@ use rustls::{ClientSession, StreamOwned};
 #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
 use super::InnerTlsParameters;
 use super::{MockStream, TlsParameters};
-use crate::transport::smtp::{error, Error};
+use crate::transport::smtp::Error;
 
 /// A network stream
 pub struct NetworkStream {
@@ -23,9 +23,6 @@ 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),
@@ -34,7 +31,7 @@ enum InnerNetworkStream {
     NativeTls(TlsStream<TcpStream>),
     /// Encrypted TCP stream
     #[cfg(feature = "rustls-tls")]
-    RustlsTls(StreamOwned<ClientSession, TcpStream>),
+    RustlsTls(Box<StreamOwned<ClientSession, TcpStream>>),
     /// Mock stream
     Mock(MockStream),
 }
@@ -84,18 +81,18 @@ impl NetworkStream {
             server: T,
             timeout: Duration,
         ) -> Result<TcpStream, Error> {
-            let addrs = server.to_socket_addrs().map_err(error::connection)?;
+            let addrs = server.to_socket_addrs()?;
             for addr in addrs {
                 if let Ok(result) = TcpStream::connect_timeout(&addr, timeout) {
                     return Ok(result);
                 }
             }
-            Err(error::connection("Could not connect"))
+            Err(Error::Client("Could not connect"))
         }
 
         let tcp_stream = match timeout {
             Some(t) => try_connect_timeout(server, t)?,
-            None => TcpStream::connect(server).map_err(error::connection)?,
+            None => TcpStream::connect(server)?,
         };
 
         let mut stream = NetworkStream::new(InnerNetworkStream::Tcp(tcp_stream));
@@ -140,21 +137,20 @@ impl NetworkStream {
             InnerTlsParameters::NativeTls(connector) => {
                 let stream = connector
                     .connect(tls_parameters.domain(), tcp_stream)
-                    .map_err(error::connection)?;
+                    .map_err(|err| Error::Io(io::Error::new(io::ErrorKind::Other, err)))?;
                 InnerNetworkStream::NativeTls(stream)
             }
             #[cfg(feature = "rustls-tls")]
             InnerTlsParameters::RustlsTls(connector) => {
                 use webpki::DNSNameRef;
 
-                let domain = DNSNameRef::try_from_ascii_str(tls_parameters.domain())
-                    .map_err(error::connection)?;
+                let domain = DNSNameRef::try_from_ascii_str(tls_parameters.domain())?;
                 let stream = StreamOwned::new(
                     ClientSession::new(&Arc::new(connector.clone()), domain),
                     tcp_stream,
                 );
 
-                InnerNetworkStream::RustlsTls(stream)
+                InnerNetworkStream::RustlsTls(Box::new(stream))
             }
         })
     }

src/transport/smtp/client/tls.rs

@@ -1,14 +1,10 @@
 #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-use crate::transport::smtp::{error, Error};
+use crate::transport::smtp::error::Error;
+
 #[cfg(feature = "native-tls")]
 use native_tls::{Protocol, TlsConnector};
 #[cfg(feature = "rustls-tls")]
-use rustls::{ClientConfig, RootCertStore, ServerCertVerified, ServerCertVerifier, TLSError};
-use std::fmt::{self, Debug};
-#[cfg(feature = "rustls-tls")]
-use std::sync::Arc;
-#[cfg(feature = "rustls-tls")]
-use webpki::DNSNameRef;
+use rustls::ClientConfig;
 
 /// Accepted protocols by default.
 /// This removes TLS 1.0 and 1.1 compared to tls-native defaults.
@@ -33,161 +29,15 @@ pub enum Tls {
     Wrapper(TlsParameters),
 }
 
-impl Debug for Tls {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match &self {
-            Self::None => f.pad("None"),
-            #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-            Self::Opportunistic(_) => f.pad("Opportunistic"),
-            #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-            Self::Required(_) => f.pad("Required"),
-            #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-            Self::Wrapper(_) => f.pad("Wrapper"),
-        }
-    }
-}
-
 /// Parameters to use for secure clients
 #[derive(Clone)]
+#[allow(missing_debug_implementations)]
 pub struct TlsParameters {
     pub(crate) connector: InnerTlsParameters,
     /// The domain name which is expected in the TLS certificate from the server
     pub(super) domain: String,
 }
 
-/// Builder for `TlsParameters`
-#[derive(Debug, 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().map_err(error::tls)?;
-        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::tls)?;
-            }
-        }
-        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")]
@@ -200,100 +50,49 @@ 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> {
-        TlsParametersBuilder::new(domain).build()
+        #[cfg(feature = "native-tls")]
+        return Self::new_native(domain);
+
+        #[cfg(not(feature = "native-tls"))]
+        return Self::new_rustls(domain);
     }
 
-    pub fn builder(domain: String) -> TlsParametersBuilder {
-        TlsParametersBuilder::new(domain)
+    #[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);
     }
 
     /// 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> {
-        TlsParametersBuilder::new(domain).build_native()
+        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,
+        })
     }
 
     /// 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> {
-        TlsParametersBuilder::new(domain).build_rustls()
+        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,
+        })
     }
 
     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>,
-}
-
-#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-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::tls)?;
-
-        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::tls)?;
-
-        #[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::tls("invalid certificates"))?
-        };
-
-        Ok(Self {
-            #[cfg(feature = "native-tls")]
-            native_tls: native_tls_cert,
-            #[cfg(feature = "rustls-tls")]
-            rustls: rustls_cert,
-        })
-    }
-}
-
-impl Debug for Certificate {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Certificate").finish()
-    }
-}
-
-#[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

@@ -1,15 +1,18 @@
 //! SMTP commands
 
 use crate::{
-    address::Address,
     transport::smtp::{
         authentication::{Credentials, Mechanism},
-        error::{self, Error},
+        error::Error,
         extension::{ClientId, MailParameter, RcptParameter},
         response::Response,
     },
+    Address,
+};
+use std::{
+    convert::AsRef,
+    fmt::{self, Display, Formatter},
 };
-use std::fmt::{self, Display, Formatter};
 
 /// EHLO command
 #[derive(PartialEq, Clone, Debug)]
@@ -19,7 +22,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)
     }
 }
@@ -37,7 +40,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")
     }
 }
@@ -51,7 +54,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:<{}>",
@@ -80,7 +83,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)?;
@@ -105,7 +108,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")
     }
 }
@@ -116,7 +119,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")
     }
 }
@@ -127,7 +130,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")
     }
 }
@@ -140,7 +143,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)?;
@@ -164,7 +167,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)
     }
 }
@@ -184,7 +187,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)
     }
 }
@@ -202,7 +205,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")
     }
 }
@@ -218,7 +221,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() {
@@ -261,17 +264,16 @@ impl Auth {
         response: &Response,
     ) -> Result<Auth, Error> {
         if !response.has_code(334) {
-            return Err(error::response("Expecting a challenge"));
+            return Err(Error::ResponseParsing("Expecting a challenge"));
         }
 
         let encoded_challenge = response
             .first_word()
-            .ok_or_else(|| error::response("Could not read auth challenge"))?;
+            .ok_or(Error::ResponseParsing("Could not read auth challenge"))?;
         #[cfg(feature = "tracing")]
         tracing::debug!("auth encoded challenge: {}", encoded_challenge);
 
-        let decoded_base64 = base64::decode(&encoded_challenge).map_err(error::response)?;
-        let decoded_challenge = String::from_utf8(decoded_base64).map_err(error::response)?;
+        let decoded_challenge = String::from_utf8(base64::decode(&encoded_challenge)?)?;
         #[cfg(feature = "tracing")]
         tracing::debug!("auth decoded challenge: {}", decoded_challenge);
 
@@ -336,7 +338,7 @@ mod test {
             "RCPT TO:<test@example.com>\r\n"
         );
         assert_eq!(
-            format!("{}", Rcpt::new(email, vec![rcpt_parameter])),
+            format!("{}", Rcpt::new(email.clone(), vec![rcpt_parameter])),
             "RCPT TO:<test@example.com> TEST=value\r\n"
         );
         assert_eq!(format!("{}", Quit), "QUIT\r\n");
@@ -367,7 +369,7 @@ mod test {
         assert_eq!(
             format!(
                 "{}",
-                Auth::new(Mechanism::Login, credentials, None).unwrap()
+                Auth::new(Mechanism::Login, credentials.clone(), None).unwrap()
             ),
             "AUTH LOGIN\r\n"
         );

src/transport/smtp/error.rs

@@ -1,185 +1,154 @@
 //! Error and result type for SMTP clients
 
-use crate::{
-    transport::smtp::response::{Code, Severity},
-    BoxError,
+use self::Error::*;
+use crate::transport::smtp::response::{Response, Severity};
+use base64::DecodeError;
+use std::{
+    error::Error as StdError,
+    fmt::{self, Display, Formatter},
+    io,
+    string::FromUtf8Error,
 };
-use std::{error::Error as StdError, fmt};
-
-// Inspired by https://github.com/seanmonstar/reqwest/blob/a8566383168c0ef06c21f38cbc9213af6ff6db31/src/error.rs
-
-/// The Errors that may occur when sending an email over SMTP
-pub struct Error {
-    inner: Box<Inner>,
-}
-
-struct Inner {
-    kind: Kind,
-    source: Option<BoxError>,
-}
-
-impl Error {
-    pub(crate) fn new<E>(kind: Kind, source: Option<E>) -> Error
-    where
-        E: Into<BoxError>,
-    {
-        Error {
-            inner: Box::new(Inner {
-                kind,
-                source: source.map(Into::into),
-            }),
-        }
-    }
-
-    /// Returns true if the error is from response
-    pub fn is_response(&self) -> bool {
-        matches!(self.inner.kind, Kind::Response)
-    }
-
-    /// Returns true if the error is from client
-    pub fn is_client(&self) -> bool {
-        matches!(self.inner.kind, Kind::Client)
-    }
-
-    /// Returns true if the error is a transient SMTP error
-    pub fn is_transient(&self) -> bool {
-        matches!(self.inner.kind, Kind::Transient(_))
-    }
-
-    /// Returns true if the error is a permanent SMTP error
-    pub fn is_permanent(&self) -> bool {
-        matches!(self.inner.kind, Kind::Permanent(_))
-    }
-
-    /// Returns true if the error is caused by a timeout
-    pub fn is_timeout(&self) -> bool {
-        let mut source = self.source();
-
-        while let Some(err) = source {
-            if let Some(io_err) = err.downcast_ref::<std::io::Error>() {
-                return io_err.kind() == std::io::ErrorKind::TimedOut;
-            }
-
-            source = err.source();
-        }
-
-        false
-    }
-
-    /// Returns true if the error is from TLS
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
-    pub fn is_tls(&self) -> bool {
-        matches!(self.inner.kind, Kind::Tls)
-    }
-
-    /// Returns the status code, if the error was generated from a response.
-    pub fn status(&self) -> Option<Code> {
-        match self.inner.kind {
-            Kind::Transient(code) => Some(code),
-            Kind::Permanent(code) => Some(code),
-            _ => None,
-        }
-    }
-}
 
+/// An enum of all error kinds.
 #[derive(Debug)]
-pub(crate) enum Kind {
+pub enum Error {
     /// Transient SMTP error, 4xx reply code
     ///
     /// [RFC 5321, section 4.2.1](https://tools.ietf.org/html/rfc5321#section-4.2.1)
-    Transient(Code),
+    Transient(Response),
     /// Permanent SMTP error, 5xx reply code
     ///
     /// [RFC 5321, section 4.2.1](https://tools.ietf.org/html/rfc5321#section-4.2.1)
-    Permanent(Code),
+    Permanent(Response),
     /// Error parsing a response
-    Response,
+    ResponseParsing(&'static str),
+    /// Error parsing a base64 string in response
+    ChallengeParsing(DecodeError),
+    /// Error parsing UTF8in response
+    Utf8Parsing(FromUtf8Error),
     /// Internal client error
-    Client,
-    /// Connection error
-    Connection,
-    /// Underlying network i/o error
-    Network,
+    Client(&'static str),
+    /// DNS resolution error
+    Resolution,
+    /// IO error
+    Io(io::Error),
     /// TLS error
-    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-    Tls,
+    #[cfg(feature = "native-tls")]
+    Tls(native_tls::Error),
+    /// Parsing error
+    Parsing(nom::error::ErrorKind),
+    /// Invalid hostname
+    #[cfg(feature = "rustls-tls")]
+    InvalidDNSName(webpki::InvalidDNSNameError),
+    #[cfg(feature = "r2d2")]
+    Pool(r2d2::Error),
 }
 
-impl fmt::Debug for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut builder = f.debug_struct("lettre::transport::smtp::Error");
-
-        builder.field("kind", &self.inner.kind);
-
-        if let Some(ref source) = self.inner.source {
-            builder.field("source", source);
+impl Display for 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",
+            }),
+            ResponseParsing(err) => fmt.write_str(err),
+            ChallengeParsing(ref err) => err.fmt(fmt),
+            Utf8Parsing(ref err) => err.fmt(fmt),
+            Resolution => fmt.write_str("could not resolve hostname"),
+            Client(err) => fmt.write_str(err),
+            Io(ref err) => err.fmt(fmt),
+            #[cfg(feature = "native-tls")]
+            Tls(ref err) => err.fmt(fmt),
+            Parsing(ref err) => fmt.write_str(err.description()),
+            #[cfg(feature = "rustls-tls")]
+            InvalidDNSName(ref err) => err.fmt(fmt),
+            #[cfg(feature = "r2d2")]
+            Pool(ref err) => err.fmt(fmt),
         }
-
-        builder.finish()
-    }
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self.inner.kind {
-            Kind::Response => f.write_str("response error")?,
-            Kind::Client => f.write_str("internal client error")?,
-            Kind::Network => f.write_str("network error")?,
-            Kind::Connection => f.write_str("Connection error")?,
-            #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-            Kind::Tls => f.write_str("tls error")?,
-            Kind::Transient(ref code) => {
-                write!(f, "transient error ({})", code)?;
-            }
-            Kind::Permanent(ref code) => {
-                write!(f, "permanent error ({})", code)?;
-            }
-        };
-
-        if let Some(ref e) = self.inner.source {
-            write!(f, ": {}", e)?;
-        }
-
-        Ok(())
     }
 }
 
 impl StdError for Error {
     fn source(&self) -> Option<&(dyn StdError + 'static)> {
-        self.inner.source.as_ref().map(|e| {
-            let r: &(dyn std::error::Error + 'static) = &**e;
-            r
+        match *self {
+            ChallengeParsing(ref err) => Some(&*err),
+            Utf8Parsing(ref err) => Some(&*err),
+            Io(ref err) => Some(&*err),
+            #[cfg(feature = "native-tls")]
+            Tls(ref err) => Some(&*err),
+            _ => None,
+        }
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(err: io::Error) -> Error {
+        Io(err)
+    }
+}
+
+#[cfg(feature = "native-tls")]
+impl From<native_tls::Error> for Error {
+    fn from(err: native_tls::Error) -> Error {
+        Tls(err)
+    }
+}
+
+impl From<nom::Err<(&str, nom::error::ErrorKind)>> for Error {
+    fn from(err: nom::Err<(&str, nom::error::ErrorKind)>) -> Error {
+        Parsing(match err {
+            nom::Err::Incomplete(_) => nom::error::ErrorKind::Complete,
+            nom::Err::Failure((_, k)) => k,
+            nom::Err::Error((_, k)) => k,
         })
     }
 }
 
-pub(crate) fn code(c: Code) -> Error {
-    match c.severity {
-        Severity::TransientNegativeCompletion => Error::new::<Error>(Kind::Transient(c), None),
-        Severity::PermanentNegativeCompletion => Error::new::<Error>(Kind::Permanent(c), None),
-        _ => client("Unknown error code"),
+impl From<DecodeError> for Error {
+    fn from(err: DecodeError) -> Error {
+        ChallengeParsing(err)
     }
 }
 
-pub(crate) fn response<E: Into<BoxError>>(e: E) -> Error {
-    Error::new(Kind::Response, Some(e))
+impl From<FromUtf8Error> for Error {
+    fn from(err: FromUtf8Error) -> Error {
+        Utf8Parsing(err)
+    }
 }
 
-pub(crate) fn client<E: Into<BoxError>>(e: E) -> Error {
-    Error::new(Kind::Client, Some(e))
+#[cfg(feature = "rustls-tls")]
+impl From<webpki::InvalidDNSNameError> for Error {
+    fn from(err: webpki::InvalidDNSNameError) -> Error {
+        InvalidDNSName(err)
+    }
 }
 
-pub(crate) fn network<E: Into<BoxError>>(e: E) -> Error {
-    Error::new(Kind::Network, Some(e))
+#[cfg(feature = "r2d2")]
+impl From<r2d2::Error> for Error {
+    fn from(err: r2d2::Error) -> Error {
+        Pool(err)
+    }
 }
 
-pub(crate) fn connection<E: Into<BoxError>>(e: E) -> Error {
-    Error::new(Kind::Connection, Some(e))
+impl From<Response> for Error {
+    fn from(response: Response) -> Error {
+        match response.code.severity {
+            Severity::TransientNegativeCompletion => Transient(response),
+            Severity::PermanentNegativeCompletion => Permanent(response),
+            _ => Client("Unknown error code"),
+        }
+    }
 }
 
-#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-pub(crate) fn tls<E: Into<BoxError>>(e: E) -> Error {
-    Error::new(Kind::Tls, Some(e))
+impl From<&'static str> for Error {
+    fn from(string: &'static str) -> Error {
+        Client(string)
+    }
 }

src/transport/smtp/extension.rs

@@ -1,10 +1,7 @@
 //! ESMTP features
 
 use crate::transport::smtp::{
-    authentication::Mechanism,
-    error::{self, Error},
-    response::Response,
-    util::XText,
+    authentication::Mechanism, error::Error, response::Response, util::XText,
 };
 use std::{
     collections::HashSet,
@@ -51,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),
@@ -61,7 +58,6 @@ impl Display for ClientId {
 }
 
 impl ClientId {
-    #[doc(hidden)]
     #[deprecated(since = "0.10.0", note = "Please use ClientId::Domain(domain) instead")]
     /// Creates a new `ClientId` from a fully qualified domain name
     pub fn new(domain: String) -> Self {
@@ -75,22 +71,22 @@ impl ClientId {
 pub enum Extension {
     /// 8BITMIME keyword
     ///
-    /// Defined in [RFC 6152](https://tools.ietf.org/html/rfc6152)
+    /// RFC 6152: https://tools.ietf.org/html/rfc6152
     EightBitMime,
     /// SMTPUTF8 keyword
     ///
-    /// Defined in [RFC 6531](https://tools.ietf.org/html/rfc6531)
+    /// RFC 6531: https://tools.ietf.org/html/rfc6531
     SmtpUtfEight,
     /// STARTTLS keyword
     ///
-    /// Defined in [RFC 2487](https://tools.ietf.org/html/rfc2487)
+    /// 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"),
@@ -115,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 {
@@ -130,7 +126,7 @@ impl ServerInfo {
     pub fn from_response(response: &Response) -> Result<ServerInfo, Error> {
         let name = match response.first_word() {
             Some(name) => name,
-            None => return Err(error::response("Could not read server name")),
+            None => return Err(Error::ResponseParsing("Could not read server name")),
         };
 
         let mut features: HashSet<Extension> = HashSet::new();
@@ -219,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),
@@ -247,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"),
@@ -269,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,
@@ -324,7 +320,7 @@ mod test {
                 "{}",
                 ServerInfo {
                     name: "name".to_string(),
-                    features: eightbitmime,
+                    features: eightbitmime.clone(),
                 }
             ),
             "name with {EightBitMime}".to_string()
@@ -351,7 +347,7 @@ mod test {
                 "{}",
                 ServerInfo {
                     name: "name".to_string(),
-                    features: plain,
+                    features: plain.clone(),
                 }
             ),
             "name with {Authentication(Plain)}".to_string()

src/transport/smtp/mod.rs

@@ -31,96 +31,133 @@
 //! This is the most basic example of usage:
 //!
 //! ```rust,no_run
-//! # #[cfg(all(feature = "builder", any(feature = "native-tls", feature = "rustls-tls")))]
-//! # fn test() -> Result<(), Box<dyn std::error::Error>> {
+//! # #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+//! # {
 //! use lettre::{Message, Transport, SmtpTransport};
 //!
 //! let email = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
+//!     .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!"))?;
+//!     .body("Be happy!")
+//!     .unwrap();
 //!
 //! // Create TLS transport on port 465
-//! let sender = SmtpTransport::relay("smtp.example.com")?
+//! let sender = SmtpTransport::relay("smtp.example.com")
+//!     .expect("relay valid")
 //!     .build();
 //! // Send the email via remote relay
 //! let result = sender.send(&email);
 //! assert!(result.is_ok());
-//! # Ok(())
 //! # }
 //! ```
+
+//! #### Complete example
 //!
-//! #### Authentication
+//! ```todo
+//! # #[cfg(feature = "smtp-transport")]
+//! # {
+//! use lettre::transport::smtp::authentication::{Credentials, Mechanism};
+//! use lettre::{Email, Envelope, Transport, SmtpClient};
+//! use lettre::transport::smtp::extension::ClientId;
 //!
-//! Example with authentication and connection pool:
+//! 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(),
+//! );
 //!
-//! ```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}}};
+//! 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(),
+//! );
 //!
-//! 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!"))?;
+//! // 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();
 //!
-//! // 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();
+//! let result_1 = mailer.send(&email_1);
+//! assert!(result_1.is_ok());
 //!
-//! // Send the email via remote relay
-//! let result = sender.send(&email);
-//! assert!(result.is_ok());
-//! # Ok(())
+//! // 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();
 //! # }
 //! ```
 //!
 //! You can specify custom TLS settings:
 //!
-//! ```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}};
+//! ```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};
 //!
-//! 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 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(),
+//!     );
 //!
-//! // Custom TLS configuration
-//! let tls = TlsParameters::builder("smtp.example.com".to_string())
-//!           .dangerous_accept_invalid_certs(true).build()?;
+//!     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()
+//!         );
 //!
-//! // Create TLS transport on port 465
-//! let sender = SmtpTransport::relay("smtp.example.com")?
-//!     // Custom TLS configuration
-//!     .tls(Tls::Required(tls))
-//!     .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();
 //!
-//! // Send the email via remote relay
-//! let result = sender.send(&email);
-//! assert!(result.is_ok());
-//! # Ok(())
+//!     let result = mailer.send(&email);
+//!
+//!     assert!(result.is_ok());
+//!
+//!     mailer.close();
 //! # }
 //! ```
+//!
 
-#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
-pub use self::async_transport::{AsyncSmtpTransport, AsyncSmtpTransportBuilder};
-#[cfg(feature = "r2d2")]
-pub use self::pool::PoolConfig;
-#[cfg(feature = "r2d2")]
+#[cfg(feature = "tokio02")]
+pub use self::async_transport::{
+    AsyncSmtpConnector, AsyncSmtpTransport, AsyncSmtpTransportBuilder, Tokio02Connector,
+};
 pub(crate) use self::transport::SmtpClient;
 pub use self::{
     error::Error,
@@ -137,7 +174,7 @@ use crate::transport::smtp::{
 use client::Tls;
 use std::time::Duration;
 
-#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
+#[cfg(feature = "tokio02")]
 mod async_transport;
 pub mod authentication;
 pub mod client;
@@ -145,7 +182,7 @@ pub mod commands;
 mod error;
 pub mod extension;
 #[cfg(feature = "r2d2")]
-mod pool;
+pub mod pool;
 pub mod response;
 mod transport;
 pub mod util;
@@ -160,13 +197,14 @@ pub const SMTP_PORT: u16 = 25;
 pub const SUBMISSION_PORT: u16 = 587;
 /// Default submission over TLS port
 ///
-/// Defined in [RFC8314](https://tools.ietf.org/html/rfc8314)
+/// https://tools.ietf.org/html/rfc8314
 pub const SUBMISSIONS_PORT: u16 = 465;
 
 /// Default timeout
 pub const DEFAULT_TIMEOUT: Duration = Duration::from_secs(60);
 
-#[derive(Debug, Clone)]
+#[allow(missing_debug_implementations)]
+#[derive(Clone)]
 struct SmtpInfo {
     /// Name sent during EHLO
     hello_name: ClientId,

src/transport/smtp/pool.rs

@@ -1,82 +1,5 @@
-use std::time::Duration;
-
-use crate::transport::smtp::{client::SmtpConnection, error, error::Error, SmtpClient};
-
-use r2d2::{CustomizeConnection, 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<Connection = SmtpConnection, Error = Error>>(
-        &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))
-            .connection_customizer(Box::new(SmtpConnectionQuitter))
-            .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),
-        }
-    }
-}
+use crate::transport::smtp::{client::SmtpConnection, error::Error, SmtpClient};
+use r2d2::ManageConnection;
 
 impl ManageConnection for SmtpClient {
     type Connection = SmtpConnection;
@@ -90,22 +13,10 @@ impl ManageConnection for SmtpClient {
         if conn.test_connected() {
             return Ok(());
         }
-        Err(error::network("is not connected anymore"))
+        Err(Error::Client("is not connected anymore"))
     }
 
     fn has_broken(&self, conn: &mut Self::Connection) -> bool {
         conn.has_broken()
     }
 }
-
-#[derive(Copy, Clone, Debug)]
-struct SmtpConnectionQuitter;
-
-impl CustomizeConnection<SmtpConnection, Error> for SmtpConnectionQuitter {
-    fn on_release(&self, conn: SmtpConnection) {
-        let mut conn = conn;
-        if !conn.has_broken() {
-            let _quit = conn.quit();
-        }
-    }
-}

src/transport/smtp/response.rs

@@ -1,7 +1,7 @@
 //! SMTP response, containing a mandatory return code and an optional text
 //! message
 
-use crate::transport::smtp::{error, Error};
+use crate::transport::smtp::Error;
 use nom::{
     branch::alt,
     bytes::streaming::{tag, take_until},
@@ -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)
     }
 }
@@ -120,14 +120,6 @@ impl Code {
             detail,
         }
     }
-
-    /// Tells if the response is positive
-    pub fn is_positive(&self) -> bool {
-        matches!(
-            self.severity,
-            Severity::PositiveCompletion | Severity::PositiveIntermediate
-        )
-    }
 }
 
 /// Contains an SMTP reply, with separated code and message
@@ -147,9 +139,7 @@ impl FromStr for Response {
     type Err = Error;
 
     fn from_str(s: &str) -> result::Result<Response, Error> {
-        parse_response(s)
-            .map(|(_, r)| r)
-            .map_err(|e| error::response(e.to_string()))
+        parse_response(s).map(|(_, r)| r).map_err(|e| e.into())
     }
 }
 
@@ -161,7 +151,10 @@ impl Response {
 
     /// Tells if the response is positive
     pub fn is_positive(&self) -> bool {
-        self.code.is_positive()
+        match self.code.severity {
+            Severity::PositiveCompletion | Severity::PositiveIntermediate => true,
+            _ => false,
+        }
     }
 
     /// Tests code equality
@@ -245,10 +238,7 @@ 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::Error::new(
-            "",
-            nom::error::ErrorKind::Not,
-        )));
+        return Err(nom::Err::Failure(("", nom::error::ErrorKind::Not)));
     }
 
     // Extract text from lines, and append last line.

src/transport/smtp/transport.rs

@@ -3,15 +3,12 @@ use std::time::Duration;
 #[cfg(feature = "r2d2")]
 use r2d2::Pool;
 
-#[cfg(feature = "r2d2")]
-use super::PoolConfig;
-#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-use super::{error, Tls, TlsParameters, SUBMISSIONS_PORT, SUBMISSION_PORT};
 use super::{ClientId, Credentials, Error, Mechanism, Response, SmtpConnection, SmtpInfo};
-use crate::{address::Envelope, Transport};
+#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+use super::{Tls, TlsParameters, SUBMISSIONS_PORT, SUBMISSION_PORT};
+use crate::{Envelope, Transport};
 
-/// Sends emails using the SMTP protocol
-#[cfg_attr(docsrs, doc(cfg(feature = "smtp-transport")))]
+#[allow(missing_debug_implementations)]
 #[derive(Clone)]
 pub struct SmtpTransport {
     #[cfg(feature = "r2d2")]
@@ -27,7 +24,7 @@ impl Transport for SmtpTransport {
     /// Sends an email
     fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
         #[cfg(feature = "r2d2")]
-        let mut conn = self.inner.get().map_err(error::client)?;
+        let mut conn = self.inner.get()?;
         #[cfg(not(feature = "r2d2"))]
         let mut conn = self.inner.connection()?;
 
@@ -41,7 +38,7 @@ impl Transport for SmtpTransport {
 }
 
 impl SmtpTransport {
-    /// Simple and secure transport, using TLS connections to communicate with the SMTP server
+    /// Simple and secure transport, using TLS connections to comunicate with the SMTP server
     ///
     /// The right option for most SMTP servers.
     ///
@@ -96,26 +93,17 @@ impl SmtpTransport {
     /// [`SmtpTransport::starttls_relay`](#method.starttls_relay) instead,
     /// if possible.
     pub fn builder_dangerous<T: Into<String>>(server: T) -> SmtpTransportBuilder {
-        let new = SmtpInfo {
-            server: server.into(),
-            ..Default::default()
-        };
-
-        SmtpTransportBuilder {
-            info: new,
-            #[cfg(feature = "r2d2")]
-            pool_config: PoolConfig::default(),
-        }
+        let mut new = SmtpInfo::default();
+        new.server = server.into();
+        SmtpTransportBuilder { info: new }
     }
 }
 
-/// Contains client configuration.
-/// Instances of this struct can be created using functions of [`SmtpTransport`].
-#[derive(Debug, Clone)]
+/// Contains client configuration
+#[allow(missing_debug_implementations)]
+#[derive(Clone)]
 pub struct SmtpTransportBuilder {
     info: SmtpInfo,
-    #[cfg(feature = "r2d2")]
-    pool_config: PoolConfig,
 }
 
 /// Builder for the SMTP `SmtpTransport`
@@ -157,25 +145,27 @@ impl SmtpTransportBuilder {
         self
     }
 
-    /// 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 client
+    fn build_client(self) -> SmtpClient {
+        SmtpClient { info: self.info }
     }
 
     /// Build the transport
     ///
     /// If the `r2d2` feature is enabled an `Arc` wrapped pool is be created.
-    /// Defaults can be found at [`PoolConfig`]
+    /// Defaults:
+    ///
+    /// * 60 seconds idle timeout
+    /// * 30 minutes max connection lifetime
+    /// * max pool size of 10 connections
     pub fn build(self) -> SmtpTransport {
-        let client = SmtpClient { info: self.info };
+        let client = self.build_client();
         SmtpTransport {
             #[cfg(feature = "r2d2")]
-            inner: self.pool_config.build(client),
+            inner: Pool::builder()
+                .min_idle(Some(0))
+                .idle_timeout(Some(Duration::from_secs(60)))
+                .build_unchecked(client),
             #[cfg(not(feature = "r2d2"))]
             inner: client,
         }
@@ -183,7 +173,7 @@ impl SmtpTransportBuilder {
 }
 
 /// Build client
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct SmtpClient {
     info: SmtpInfo,
 }
@@ -200,7 +190,6 @@ 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,31 +7,27 @@
 //! testing purposes.
 //!
 //! ```rust
-//! # #[cfg(feature = "builder")]
-//! # {
-//! use lettre::{transport::stub::StubTransport, Message, Transport};
+//! use lettre::{Message, Envelope, Transport, StubTransport};
 //!
-//! # use std::error::Error;
-//! # fn main() -> Result<(), Box<dyn Error>> {
 //! let email = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
+//!     .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!"))?;
+//!     .body("Be happy!")
+//!     .unwrap();
 //!
 //! let mut sender = StubTransport::new_ok();
 //! let result = sender.send(&email);
 //! assert!(result.is_ok());
-//! # Ok(())
-//! # }
-//! # }
 //! ```
 
-#[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"))]
+#[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 async_trait::async_trait;
 use std::{error::Error as StdError, fmt};
 
@@ -53,7 +49,7 @@ pub struct StubTransport {
 }
 
 impl StubTransport {
-    /// Creates a new transport that always returns the given Result
+    /// Creates aResult new transport that always returns the given response
     pub fn new(response: Result<(), Error>) -> StubTransport {
         StubTransport { response }
     }
@@ -80,9 +76,20 @@ impl Transport for StubTransport {
     }
 }
 
-#[cfg(any(feature = "tokio02", feature = "tokio1", feature = "async-std1"))]
+#[cfg(feature = "async-std1")]
 #[async_trait]
-impl AsyncTransport for StubTransport {
+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 {
     type Ok = ();
     type Error = Error;
 

testdata/email_with_png.eml

@@ -1,233 +0,0 @@
-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,14 +1,19 @@
 #[cfg(test)]
-#[cfg(all(feature = "file-transport", feature = "builder"))]
-mod sync {
-    use lettre::{FileTransport, Message, Transport};
+#[cfg(feature = "file-transport")]
+mod test {
+    use lettre::{transport::file::FileTransport, Message};
     use std::{
         env::temp_dir,
-        fs::{read_to_string, remove_file},
+        fs::{remove_file, File},
+        io::Read,
     };
 
+    #[cfg(feature = "tokio02")]
+    use tokio02_crate as tokio;
+
     #[test]
     fn file_transport() {
+        use lettre::Transport;
         let sender = FileTransport::new(temp_dir());
         let email = Message::builder()
             .from("NoBody <nobody@domain.tld>".parse().unwrap())
@@ -16,219 +21,78 @@ mod sync {
             .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!"))
+            .body("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 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);
 
         assert_eq!(
-            eml,
-            concat!(
-                "From: NoBody <nobody@domain.tld>\r\n",
-                "Reply-To: Yuin <yuin@domain.tld>\r\n",
-                "To: Hei <hei@domain.tld>\r\n",
-                "Subject: Happy new year\r\n",
-                "Date: Tue, 15 Nov 1994 08:12:31 GMT\r\n",
-                "Content-Transfer-Encoding: 7bit\r\n",
-                "\r\n",
-                "Be happy!"
-            )
-        );
-        remove_file(eml_file).unwrap();
+            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();
     }
 
-    #[test]
-    #[cfg(feature = "file-transport-envelope")]
-    fn file_transport_with_envelope() {
-        let sender = FileTransport::with_envelope(temp_dir());
+    #[cfg(feature = "async-std1")]
+    #[async_attributes::test]
+    async fn file_transport_asyncstd1() {
+        use lettre::AsyncStd1Transport;
+
+        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())
             .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);
-        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(test)]
-#[cfg(all(feature = "file-transport", feature = "builder", feature = "tokio02"))]
-mod tokio_02 {
-    use lettre::{AsyncFileTransport, AsyncTransport, Message, Tokio02Executor};
-    use std::{
-        env::temp_dir,
-        fs::{read_to_string, remove_file},
-    };
-
-    use tokio02_crate as tokio;
-
-    #[tokio::test]
-    async fn file_transport_tokio02() {
-        let sender = AsyncFileTransport::<Tokio02Executor>::new(temp_dir());
-        let email = Message::builder()
-            .from("NoBody <nobody@domain.tld>".parse().unwrap())
-            .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-            .to("Hei <hei@domain.tld>".parse().unwrap())
-            .subject("Happy new year")
-            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
-            .body(String::from("Be happy!"))
+            .body("Be happy!")
             .unwrap();
 
         let result = sender.send(email).await;
         let id = result.unwrap();
 
-        let eml_file = temp_dir().join(format!("{}.eml", id));
-        let eml = read_to_string(&eml_file).unwrap();
+        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);
 
         assert_eq!(
-            eml,
-            concat!(
-                "From: NoBody <nobody@domain.tld>\r\n",
-                "Reply-To: Yuin <yuin@domain.tld>\r\n",
-                "To: Hei <hei@domain.tld>\r\n",
-                "Subject: Happy new year\r\n",
-                "Date: Tue, 15 Nov 1994 08:12:31 GMT\r\n",
-                "Content-Transfer-Encoding: 7bit\r\n",
-                "\r\n",
-                "Be happy!"
-            )
-        );
-        remove_file(eml_file).unwrap();
+            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();
     }
-}
-
-#[cfg(test)]
-#[cfg(all(feature = "file-transport", feature = "builder", feature = "tokio1"))]
-mod tokio_1 {
-    use lettre::{AsyncFileTransport, AsyncTransport, Message, Tokio1Executor};
-    use std::{
-        env::temp_dir,
-        fs::{read_to_string, remove_file},
-    };
-
-    use tokio1_crate as tokio;
 
     #[cfg(feature = "tokio02")]
     #[tokio::test]
-    async fn file_transport_tokio1() {
-        let sender = AsyncFileTransport::<Tokio1Executor>::new(temp_dir());
+    async fn file_transport_tokio02() {
+        use lettre::Tokio02Transport;
+
+        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())
             .subject("Happy new year")
             .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
-            .body(String::from("Be happy!"))
+            .body("Be happy!")
             .unwrap();
 
         let result = sender.send(email).await;
         let id = result.unwrap();
 
-        let eml_file = temp_dir().join(format!("{}.eml", id));
-        let eml = read_to_string(&eml_file).unwrap();
+        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);
 
         assert_eq!(
-            eml,
-            concat!(
-                "From: NoBody <nobody@domain.tld>\r\n",
-                "Reply-To: Yuin <yuin@domain.tld>\r\n",
-                "To: Hei <hei@domain.tld>\r\n",
-                "Subject: Happy new year\r\n",
-                "Date: Tue, 15 Nov 1994 08:12:31 GMT\r\n",
-                "Content-Transfer-Encoding: 7bit\r\n",
-                "\r\n",
-                "Be happy!"
-            )
-        );
-        remove_file(eml_file).unwrap();
-    }
-}
-
-#[cfg(test)]
-#[cfg(all(
-    feature = "file-transport",
-    feature = "builder",
-    feature = "async-std1"
-))]
-mod asyncstd_1 {
-    use lettre::{AsyncFileTransport, AsyncStd1Executor, AsyncTransport, Message};
-    use std::{
-        env::temp_dir,
-        fs::{read_to_string, remove_file},
-    };
-
-    #[async_std::test]
-    async fn file_transport_asyncstd1() {
-        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 eml_file = temp_dir().join(format!("{}.eml", id));
-        let eml = read_to_string(&eml_file).unwrap();
-
-        assert_eq!(
-            eml,
-            concat!(
-                "From: NoBody <nobody@domain.tld>\r\n",
-                "Reply-To: Yuin <yuin@domain.tld>\r\n",
-                "To: Hei <hei@domain.tld>\r\n",
-                "Subject: Happy new year\r\n",
-                "Date: Tue, 15 Nov 1994 08:12:31 GMT\r\n",
-                "Content-Transfer-Encoding: 7bit\r\n",
-                "\r\n",
-                "Be happy!"
-            )
-        );
-        remove_file(eml_file).unwrap();
+            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();
     }
 }

tests/transport_sendmail.rs

@@ -1,104 +1,63 @@
 #[cfg(test)]
-#[cfg(all(feature = "sendmail-transport", feature = "builder"))]
-mod sync {
-    use lettre::{Message, SendmailTransport, Transport};
+#[cfg(feature = "sendmail-transport")]
+mod test {
+    use lettre::{transport::sendmail::SendmailTransport, Message};
+
+    #[cfg(feature = "tokio02")]
+    use tokio02_crate as tokio;
 
     #[test]
     fn sendmail_transport() {
+        use lettre::Transport;
         let sender = SendmailTransport::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")
-            .body(String::from("Be happy!"))
+            .body("Be happy!")
             .unwrap();
 
         let result = sender.send(&email);
         println!("{:?}", result);
         assert!(result.is_ok());
     }
-}
 
-#[cfg(test)]
-#[cfg(all(
-    feature = "sendmail-transport",
-    feature = "builder",
-    feature = "tokio02"
-))]
-mod tokio_02 {
-    use lettre::{AsyncSendmailTransport, AsyncTransport, Message, Tokio02Executor};
-    use tokio02_crate as tokio;
+    #[cfg(feature = "async-std1")]
+    #[async_attributes::test]
+    async fn sendmail_transport_asyncstd1() {
+        use lettre::AsyncStd1Transport;
 
+        let sender = SendmailTransport::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!")
+            .unwrap();
+
+        let result = sender.send(email).await;
+        assert!(result.is_ok());
+    }
+
+    #[cfg(feature = "tokio02")]
     #[tokio::test]
     async fn sendmail_transport_tokio02() {
-        let sender = AsyncSendmailTransport::<Tokio02Executor>::new();
+        use lettre::Tokio02Transport;
+
+        let sender = SendmailTransport::new();
         let email = Message::builder()
             .from("NoBody <nobody@domain.tld>".parse().unwrap())
             .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
             .to("Hei <hei@domain.tld>".parse().unwrap())
             .subject("Happy new year")
             .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
-            .body(String::from("Be happy!"))
+            .body("Be happy!")
             .unwrap();
 
         let result = sender.send(email).await;
-        println!("{:?}", result);
-        assert!(result.is_ok());
-    }
-}
-
-#[cfg(test)]
-#[cfg(all(
-    feature = "sendmail-transport",
-    feature = "builder",
-    feature = "tokio1"
-))]
-mod tokio_1 {
-    use lettre::{AsyncSendmailTransport, AsyncTransport, Message, Tokio1Executor};
-    use tokio1_crate as tokio;
-
-    #[tokio::test]
-    async fn sendmail_transport_tokio1() {
-        let sender = AsyncSendmailTransport::<Tokio1Executor>::new();
-        let email = Message::builder()
-            .from("NoBody <nobody@domain.tld>".parse().unwrap())
-            .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-            .to("Hei <hei@domain.tld>".parse().unwrap())
-            .subject("Happy new year")
-            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
-            .body(String::from("Be happy!"))
-            .unwrap();
-
-        let result = sender.send(email).await;
-        println!("{:?}", result);
-        assert!(result.is_ok());
-    }
-}
-
-#[cfg(test)]
-#[cfg(all(
-    feature = "sendmail-transport",
-    feature = "builder",
-    feature = "async-std1"
-))]
-mod asyncstd_1 {
-    use lettre::{AsyncSendmailTransport, AsyncStd1Executor, AsyncTransport, Message};
-
-    #[async_std::test]
-    async fn sendmail_transport_asyncstd1() {
-        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(String::from("Be happy!"))
-            .unwrap();
-
-        let result = sender.send(email).await;
-        println!("{:?}", result);
         assert!(result.is_ok());
     }
 }

tests/transport_smtp.rs

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

tests/transport_smtp_pool.rs

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

tests/transport_stub.rs

@@ -1,94 +1,61 @@
-#[cfg(test)]
-#[cfg(feature = "builder")]
-mod sync {
-    use lettre::{transport::stub::StubTransport, Message, Transport};
+use lettre::{transport::stub::StubTransport, Message};
 
-    #[test]
-    fn stub_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();
+#[cfg(feature = "tokio02")]
+use tokio02_crate as tokio;
 
-        sender_ok.send(&email).unwrap();
-        sender_ko.send(&email).unwrap_err();
-    }
+#[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();
+
+    sender_ok.send(&email).unwrap();
+    sender_ko.send(&email).unwrap_err();
 }
 
-#[cfg(test)]
-#[cfg(all(feature = "builder", feature = "tokio02"))]
-mod tokio_02 {
-    use lettre::{transport::stub::StubTransport, AsyncTransport, Message};
+#[cfg(feature = "async-std1")]
+#[async_attributes::test]
+async fn stub_transport_asyncstd1() {
+    use lettre::AsyncStd1Transport;
 
-    use tokio02_crate as tokio;
+    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();
 
-    #[tokio::test]
-    async fn stub_transport_tokio02() {
-        let sender_ok = StubTransport::new_ok();
-        let sender_ko = StubTransport::new_error();
-        let email = Message::builder()
-            .from("NoBody <nobody@domain.tld>".parse().unwrap())
-            .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-            .to("Hei <hei@domain.tld>".parse().unwrap())
-            .subject("Happy new year")
-            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
-            .body(String::from("Be happy!"))
-            .unwrap();
-
-        sender_ok.send(email.clone()).await.unwrap();
-        sender_ko.send(email).await.unwrap_err();
-    }
+    sender_ok.send(email.clone()).await.unwrap();
+    sender_ko.send(email).await.unwrap_err();
 }
 
-#[cfg(test)]
-#[cfg(all(feature = "builder", feature = "tokio1"))]
-mod tokio_1 {
-    use lettre::{transport::stub::StubTransport, AsyncTransport, Message};
+#[cfg(feature = "tokio02")]
+#[tokio::test]
+async fn stub_transport_tokio02() {
+    use lettre::Tokio02Transport;
 
-    use tokio1_crate as tokio;
+    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();
 
-    #[tokio::test]
-    async fn stub_transport_tokio1() {
-        let sender_ok = StubTransport::new_ok();
-        let sender_ko = StubTransport::new_error();
-        let email = Message::builder()
-            .from("NoBody <nobody@domain.tld>".parse().unwrap())
-            .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-            .to("Hei <hei@domain.tld>".parse().unwrap())
-            .subject("Happy new year")
-            .date("Tue, 15 Nov 1994 08:12:31 GMT".parse().unwrap())
-            .body(String::from("Be happy!"))
-            .unwrap();
-
-        sender_ok.send(email.clone()).await.unwrap();
-        sender_ko.send(email).await.unwrap_err();
-    }
-}
-
-#[cfg(test)]
-#[cfg(all(feature = "builder", feature = "async-std1"))]
-mod asyncstd_1 {
-    use lettre::{transport::stub::StubTransport, AsyncTransport, Message};
-
-    #[async_std::test]
-    async fn stub_transport_asyncstd1() {
-        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();
-    }
+    sender_ok.send(email.clone()).await.unwrap();
+    sender_ko.send(email).await.unwrap_err();
 }