wip

And then downgrades:

cargo update -p clap --precise 4.3.24
cargo update -p clap_lex --precise 0.5.0
cargo update -p anstyle --precise 1.0.2

.editorconfig

@@ -0,0 +1,8 @@
+root = true
+
+[*]
+insert_final_newline = true
+
+[*.rs]
+indent_size = 4
+indent_style = space

.github/workflows/test.yml

@@ -7,20 +7,22 @@ on:
       - master
 
 env:
+  RUSTFLAGS: "--cfg lettre_ignore_tls_mismatch"
+  RUSTDOCFLAGS: "--cfg lettre_ignore_tls_mismatch"
   RUST_BACKTRACE: full
 
 jobs:
   rustfmt:
-    name: rustfmt / stable
+    name: rustfmt / nightly-2024-09-01
     runs-on: ubuntu-latest
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - name: Install rust
         run: |
-          rustup update --no-self-update stable
+          rustup default nightly-2024-09-01
           rustup component add rustfmt
 
       - name: cargo fmt
@@ -32,7 +34,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - name: Install rust
         run: |
@@ -48,20 +50,14 @@ jobs:
 
     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
+        uses: actions/checkout@v4
 
       - name: Install rust
         run: rustup update --no-self-update stable
 
+      - name: Setup cache
+        uses: Swatinem/rust-cache@v2
+      
       - name: Install cargo hack
         run: cargo install cargo-hack --debug
 
@@ -79,27 +75,21 @@ jobs:
             rust: stable
           - name: beta
             rust: beta
-          - name: 1.46.0
-            rust: 1.46.0
+          - name: '1.70'
+            rust: '1.70'
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Setup cache
-        uses: actions/cache@v2
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-          key: ${{ runner.os }}-cargo-test-${{ matrix.rust }}
+        uses: actions/checkout@v4
 
       - name: Install rust
         run: |
           rustup default ${{ matrix.rust }}
           rustup update --no-self-update ${{ matrix.rust }}
 
+      - name: Setup cache
+        uses: Swatinem/rust-cache@v2
+
       - name: Install postfix  
         run: |
           DEBIAN_FRONTEND=noninteractive sudo apt-get update
@@ -108,20 +98,37 @@ jobs:
       - name: Run SMTP server
         run: smtp-sink 2525 1000&
 
+      - name: Install coredns
+        run: |
+          wget -q https://github.com/coredns/coredns/releases/download/v1.8.6/coredns_1.8.6_linux_amd64.tgz
+          tar xzf coredns_1.8.6_linux_amd64.tgz
+
+      - name: Start coredns
+        run: |
+          sudo ./coredns -conf testdata/coredns.conf &
+          sudo systemctl stop systemd-resolved
+          echo "nameserver 127.0.0.54" | sudo tee /etc/resolv.conf
+
+      - name: Install dkimverify
+        run: sudo apt -y install python3-dkim
+
       - 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
+      - name: Test with all features (-native-tls)
+        run: cargo test --no-default-features --features async-std1,async-std1-rustls-tls,boring-tls,builder,dkim,file-transport,file-transport-envelope,hostname,mime03,pool,rustls-native-certs,rustls-tls,sendmail-transport,smtp-transport,tokio1,tokio1-boring-tls,tokio1-rustls-tls,tracing
+  
+      - name: Test with all features (-boring-tls)
+        run: cargo test --no-default-features --features async-std1,async-std1-rustls-tls,builder,dkim,file-transport,file-transport-envelope,hostname,mime03,native-tls,pool,rustls-native-certs,rustls-tls,sendmail-transport,smtp-transport,tokio1,tokio1-native-tls,tokio1-rustls-tls,tracing
 
 #  coverage:
 #    name: Coverage
 #    runs-on: ubuntu-latest
 #    steps:
-#      - uses: actions/checkout@v2
+#      - uses: actions/checkout@v4
 #      - uses: actions-rs/toolchain@v1
 #        with:
 #          toolchain: nightly

.gitignore

@@ -4,4 +4,3 @@
 lettre.sublime-*
 lettre.iml
 target/
-/Cargo.lock

CHANGELOG.md

@@ -1,11 +1,295 @@
+<a name="v0.11.9"></a>
+### v0.11.9 (2024-09-13)
+
+#### Bug fixes
+
+* Fix feature gate for `accept_invalid_hostnames` for rustls ([#988])
+* Fix parsing `Mailbox` with trailing spaces ([#986])
+
+#### Misc
+
+* Bump `rustls-native-certs` to v0.8 ([#992])
+* Make getting started example in readme complete ([#990])
+
+[#988]: https://github.com/lettre/lettre/pull/988
+[#986]: https://github.com/lettre/lettre/pull/986
+[#990]: https://github.com/lettre/lettre/pull/990
+[#992]: https://github.com/lettre/lettre/pull/992
+
+<a name="v0.11.8"></a>
+### v0.11.8 (2024-09-03)
+
+#### Features
+
+* Add mTLS support ([#974])
+* Implement `accept_invalid_hostnames` for rustls ([#977])
+* Provide certificate chain for peer certificates when using `rustls` or `boring-tls` ([#976])
+
+#### Changes
+
+* Make `HeaderName` comparisons via `PartialEq` case insensitive ([#980])
+
+#### Misc
+
+* Fix clippy warnings ([#979])
+* Replace manual impl of `#[non_exhaustive]` for `InvalidHeaderName` ([#981])
+
+[#974]: https://github.com/lettre/lettre/pull/974
+[#976]: https://github.com/lettre/lettre/pull/976
+[#977]: https://github.com/lettre/lettre/pull/977
+[#980]: https://github.com/lettre/lettre/pull/980
+[#981]: https://github.com/lettre/lettre/pull/981
+
+<a name="v0.11.7"></a>
+### v0.11.7 (2024-04-23)
+
+#### Misc
+
+* Bump `hostname` to v0.4 ([#956])
+* Fix `tracing` message consistency ([#960])
+* Bump minimum required `rustls` to v0.23.5 ([#958])
+* Dropped use of `ref` syntax in the entire project ([#959])
+
+[#956]: https://github.com/lettre/lettre/pull/956
+[#958]: https://github.com/lettre/lettre/pull/958
+[#959]: https://github.com/lettre/lettre/pull/959
+[#960]: https://github.com/lettre/lettre/pull/960
+
+<a name="v0.11.6"></a>
+### v0.11.6 (2024-03-28)
+
+#### Bug fixes
+
+* Upgraded `email-encoding` to v0.3 - fixing multiple encoding bugs in the process ([#952])
+
+#### Misc
+
+* Updated copyright year in license ([#954])
+
+[#952]: https://github.com/lettre/lettre/pull/952
+[#954]: https://github.com/lettre/lettre/pull/954
+
+<a name="v0.11.5"></a>
+### v0.11.5 (2024-03-25)
+
+#### Features
+
+* Support SMTP SASL draft login challenge ([#911])
+* Add conversion from SMTP response code to integer ([#941])
+
+#### Misc
+
+* Upgrade `rustls` to v0.23 ([#950])
+* Bump `base64` to v0.22 ([#945])
+* Fix typos in documentation ([#943], [#944])
+* Add `Cargo.lock` ([#942])
+
+[#911]: https://github.com/lettre/lettre/pull/911
+[#941]: https://github.com/lettre/lettre/pull/941
+[#942]: https://github.com/lettre/lettre/pull/942
+[#943]: https://github.com/lettre/lettre/pull/943
+[#944]: https://github.com/lettre/lettre/pull/944
+[#945]: https://github.com/lettre/lettre/pull/945
+[#950]: https://github.com/lettre/lettre/pull/950
+
+<a name="v0.11.4"></a>
+### v0.11.4 (2024-01-28)
+
+#### Bug fixes
+
+* Percent decode credentials in SMTP connect URL ([#932], [#934])
+* Fix mimebody DKIM body-hash computation ([#923])
+
+[#923]: https://github.com/lettre/lettre/pull/923
+[#932]: https://github.com/lettre/lettre/pull/932
+[#934]: https://github.com/lettre/lettre/pull/934
+
+<a name="v0.11.3"></a>
+### v0.11.3 (2024-01-02)
+
+#### Features
+
+* Derive `Clone` for `FileTransport` and `AsyncFileTransport` ([#924])
+* Derive `Debug` for `SmtpTransport` ([#925])
+
+#### Misc
+
+* Upgrade `rustls` to v0.22 ([#921])
+* Drop once_cell dependency in favor of OnceLock from std ([#928])
+
+[#921]: https://github.com/lettre/lettre/pull/921
+[#924]: https://github.com/lettre/lettre/pull/924
+[#925]: https://github.com/lettre/lettre/pull/925
+[#928]: https://github.com/lettre/lettre/pull/928
+
+<a name="v0.11.2"></a>
+### v0.11.2 (2023-11-23)
+
+#### Upgrade notes
+
+* MSRV is now 1.70 ([#916])
+
+#### Misc
+
+* Bump `idna` to v0.5 ([#918])
+* Bump `boring` and `tokio-boring` to v4 ([#915])
+
+[#915]: https://github.com/lettre/lettre/pull/915
+[#916]: https://github.com/lettre/lettre/pull/916
+[#918]: https://github.com/lettre/lettre/pull/918
+
+<a name="v0.11.1"></a>
+### v0.11.1 (2023-10-24)
+
+#### Bug fixes
+
+* Fix `webpki-roots` certificate store setup ([#909])
+
+[#909]: https://github.com/lettre/lettre/pull/909
+
+<a name="v0.11.0"></a>
+### v0.11.0 (2023-10-15)
+
+While this release technically contains breaking changes, we expect most projects
+to be able to upgrade by only bumping the version in `Cargo.toml`.
+
+#### Upgrade notes
+
+* MSRV is now 1.65 ([#869] and [#881])
+* `AddressError` is now marked as `#[non_exhaustive]` ([#839])
+
+#### Features
+
+* Improve mailbox parsing ([#839])
+* Add construction of SMTP transport from URL ([#901])
+* Add `From<Address>` implementation for `Mailbox` ([#879])
+
+#### Misc
+
+* Bump `socket2` to v0.5 ([#868])
+* Bump `idna` to v0.4, `fastrand` to v2, `quoted_printable` to v0.5, `rsa` to v0.9 ([#882])
+* Bump `webpki-roots` to v0.25 ([#884] and [#890])
+* Bump `ed25519-dalek` to v2 fixing RUSTSEC-2022-0093 ([#896])
+* Bump `boring`ssl crates to v3 ([#897])
+
+[#839]: https://github.com/lettre/lettre/pull/839
+[#868]: https://github.com/lettre/lettre/pull/868
+[#869]: https://github.com/lettre/lettre/pull/869
+[#879]: https://github.com/lettre/lettre/pull/879
+[#881]: https://github.com/lettre/lettre/pull/881
+[#882]: https://github.com/lettre/lettre/pull/882
+[#884]: https://github.com/lettre/lettre/pull/884
+[#890]: https://github.com/lettre/lettre/pull/890
+[#896]: https://github.com/lettre/lettre/pull/896
+[#897]: https://github.com/lettre/lettre/pull/897
+[#901]: https://github.com/lettre/lettre/pull/901
+
+<a name="v0.10.4"></a>
+### v0.10.4 (2023-04-02)
+
+#### Misc
+
+* Bumped rustls to 0.21 and all related dependencies ([#867])
+
+[#867]: https://github.com/lettre/lettre/pull/867
+
+<a name="v0.10.3"></a>
+### v0.10.3 (2023-02-20)
+
+#### Announcements
+
+It was found that what had been used until now as a basic lettre 0.10
+`MessageBuilder::body` example failed to mention that for maximum
+compatibility with various email clients a `Content-Type` header
+should always be present in the message.
+
+##### Before
+
+```rust
+Message::builder()
+  // [...] some headers skipped for brevity
+  .body(String::from("A plaintext or html body"))?
+```
+
+##### Patch
+
+```diff
+ Message::builder()
+   // [...] some headers skipped for brevity
++  .header(ContentType::TEXT_PLAIN) // or `TEXT_HTML` if the body is html
+   .body(String::from("A plaintext or html body"))?
+```
+
+#### Features
+
+* Add support for rustls-native-certs when using rustls ([#843])
+
+[#843]: https://github.com/lettre/lettre/pull/843
+
+<a name="v0.10.2"></a>
+### v0.10.2 (2023-01-29)
+
+#### Upgrade notes
+
+* MSRV is now 1.60 ([#828])
+
+#### Features
+
+* Allow providing a custom `tokio` stream for `AsyncSmtpTransport` ([#805])
+* Return whole SMTP error message ([#821])
+
+#### Bug fixes
+
+* Mailbox displays wrongly when containing a comma and a non-ascii char in its name ([#827])
+* Require `quoted_printable` ^0.4.6 in order to fix encoding of tabs and spaces at the end of line ([#837])
+
+#### Misc
+
+* Increase tracing ([#848])
+* Bump `idna` to 0.3 ([#816])
+* Update `base64` to 0.21 ([#840] and [#851])
+* Update `rsa` to 0.8 ([#829] and [#852])
+
+[#805]: https://github.com/lettre/lettre/pull/805
+[#816]: https://github.com/lettre/lettre/pull/816
+[#821]: https://github.com/lettre/lettre/pull/821
+[#827]: https://github.com/lettre/lettre/pull/827
+[#828]: https://github.com/lettre/lettre/pull/828
+[#829]: https://github.com/lettre/lettre/pull/829
+[#837]: https://github.com/lettre/lettre/pull/837
+[#840]: https://github.com/lettre/lettre/pull/840
+[#848]: https://github.com/lettre/lettre/pull/848
+[#851]: https://github.com/lettre/lettre/pull/851
+[#852]: https://github.com/lettre/lettre/pull/852
+
+<a name="v0.10.1"></a>
+### v0.10.1 (2022-07-20)
+
+#### Features
+
+* Add `boring-tls` support for `SmtpTransport` and `AsyncSmtpTransport`. The latter is only supported with the tokio runtime. ([#797]) ([#798])
+* Make the minimum TLS version configurable. ([#799]) ([#800])
+
+#### Bug Fixes
+
+* Ensure connections are closed on abort. ([#801])
+* Fix SMTP dot stuffing. ([#803])
+
+[#797]: https://github.com/lettre/lettre/pull/797
+[#798]: https://github.com/lettre/lettre/pull/798
+[#799]: https://github.com/lettre/lettre/pull/799
+[#800]: https://github.com/lettre/lettre/pull/800
+[#801]: https://github.com/lettre/lettre/pull/801
+[#803]: https://github.com/lettre/lettre/pull/803
+
 <a name="v0.10.0"></a>
-### v0.10.0 (unreleased)
+### v0.10.0 (2022-06-29)
 
 #### Upgrade notes
 
 Several breaking changes were made between 0.9 and 0.10, but changes should be straightforward:
 
-* MSRV is now 1.46
+* MSRV is now 1.56.0
 * The `lettre_email` crate has been merged into `lettre`. To migrate, replace `lettre_email` with `lettre::message`
   and make sure to enable the `builder` feature (it's enabled by default).
 * `SendableEmail` has been renamed to `Email` and `EmailBuilder::build()` produces it directly. To migrate,
@@ -29,9 +313,11 @@ Several breaking changes were made between 0.9 and 0.10, but changes should be s
 * Refactor `TlsParameters` implementation to not expose the internal TLS library
 * `FileTransport` writes emails into `.eml` instead of `.json`
 * When the hostname feature is disabled or hostname cannot be fetched, `127.0.0.1` is used instead of `localhost` as EHLO parameter (for better RFC compliance and mail server compatibility)
+* The `sendmail` and `file` transports aren't enabled by default anymore.
 * The `new` method of `ClientId` is deprecated
 * Rename `serde-impls` feature to `serde`
-
+* The `SendmailTransport` now uses the `sendmail` command in current `PATH` by default instead of
+  `/usr/bin/sendmail`.
 
 #### Bug Fixes
 
@@ -52,7 +338,7 @@ Several breaking changes were made between 0.9 and 0.10, but changes should be s
 * Update `hostname` to 0.3
 * Update to `nom` 6
 * Replace `log` with `tracing`
-* Move CI to Github Actions
+* Move CI to GitHub Actions
 * Use criterion for benchmarks
 
 <a name="v0.9.2"></a>

CONTRIBUTING.md

@@ -1,6 +1,6 @@
 ## Contributing to Lettre
 
-The following guidelines are inspired from the [hyper project](https://github.com/hyperium/hyper/blob/master/CONTRIBUTING.md).
+The following guidelines are inspired by the [hyper project](https://github.com/hyperium/hyper/blob/master/CONTRIBUTING.md).
 
 ### Code formatting
 

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "lettre"
 # remember to update html_root_url and README.md (Cargo.toml example and deps.rs badge)
-version = "0.10.0-rc.1"
+version = "0.11.9"
 description = "Email client"
 readme = "README.md"
 homepage = "https://lettre.rs"
@@ -10,7 +10,8 @@ license = "MIT"
 authors = ["Alexis Mousset <contact@amousset.me>", "Paolo Barbolini <paolo@paolo565.org>"]
 categories = ["email", "network-programming"]
 keywords = ["email", "smtp", "mailer", "message", "sendmail"]
-edition = "2018"
+edition = "2021"
+rust-version = "1.70"
 
 [badges]
 is-it-maintained-issue-resolution = { repository = "lettre/lettre" }
@@ -18,33 +19,38 @@ is-it-maintained-open-issues = { repository = "lettre/lettre" }
 maintenance = { status = "actively-developed" }
 
 [dependencies]
-idna = "0.2"
+chumsky = "0.9"
+idna = "1"
 tracing = { version = "0.1.16", default-features = false, features = ["std"], optional = true } # feature
 
 # builder
 httpdate = { version = "1", optional = true }
 mime = { version = "0.3.4", optional = true }
-fastrand = { version = "1.4", optional = true }
-quoted_printable = { version = "0.4", optional = true }
-base64 = { version = "0.13", optional = true }
-once_cell = "1"
-regex = { version = "1", default-features = false, features = ["std", "unicode-case"] }
+fastrand = { version = "2.0", optional = true }
+quoted_printable = { version = "0.5", optional = true }
+base64 = { version = "0.22", optional = true }
+email-encoding = { version = "0.3", optional = true }
 
 # file transport
-uuid = { version = "0.8", features = ["v4"], optional = true }
+uuid = { version = "1", features = ["v4"], optional = true }
 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
+# smtp-transport
+nom = { version = "7", optional = true }
+hostname = { version = "0.4", optional = true } # feature
+socket2 = { version = "0.5.1", optional = true }
+url = { version = "2.4", optional = true }
+percent-encoding = { version = "2.3", optional = true }
 
 ## 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 }
+native-tls = { version = "0.2.5", optional = true } # feature
+rustls = { version = "0.23.5", default-features = false, features = ["ring", "logging", "std", "tls12"], optional = true }
+rustls-pemfile = { version = "2", optional = true }
+rustls-native-certs = { version = "0.8", optional = true }
+rustls-pki-types = { version = "1.7", optional = true }
+webpki-roots = { version = "0.26", optional = true }
+boring = { version = "4", optional = true }
 
 # async
 futures-io = { version = "0.3.7", optional = true }
@@ -52,52 +58,80 @@ futures-util = { version = "0.3.7", default-features = false, features = ["io"],
 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 }
+async-std = { version = "1.8", optional = true }
+futures-rustls = { version = "0.26", default-features = false, features = ["logging", "tls12", "ring"], optional = true }
 
 ## tokio
-tokio1_crate = { package = "tokio", version = "1", features = ["fs", "process", "net", "io-util"], optional = true }
+tokio1_crate = { package = "tokio", version = "1", 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 }
+tokio1_rustls = { package = "tokio-rustls", version = "0.26", default-features = false, features = ["logging", "tls12", "ring"], optional = true }
+tokio1_boring = { package = "tokio-boring", version = "4", optional = true }
+
+## dkim
+sha2 = { version = "0.10", optional = true, features = ["oid"] }
+rsa = { version = "0.9", optional = true }
+ed25519-dalek = { version = "2", optional = true }
+
+# email formats
+email_address = { version = "0.2.1", default-features = false }
 
 [dev-dependencies]
-criterion = "0.3"
-tracing-subscriber = "0.2.10"
+pretty_assertions = "1"
+criterion = "0.5"
+tracing = { version = "0.1.16", default-features = false, features = ["std"] }
+tracing-subscriber = "0.3"
 glob = "0.3"
 walkdir = "2"
 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"
+maud = "0.26"
 
 [[bench]]
 harness = false
 name = "transport_smtp"
 
+[[bench]]
+harness = false
+name = "mailbox_parsing"
+
 [features]
-default = ["smtp-transport", "native-tls", "hostname", "r2d2", "builder"]
-builder = ["httpdate", "mime", "base64", "fastrand", "quoted_printable"]
+default = ["smtp-transport", "pool", "native-tls", "hostname", "builder"]
+builder = ["dep:httpdate", "dep:mime", "dep:fastrand", "dep:quoted_printable", "dep:email-encoding"]
+mime03 = ["dep:mime"]
 
 # transports
-file-transport = ["uuid"]
-file-transport-envelope = ["serde", "serde_json", "file-transport"]
-sendmail-transport = []
-smtp-transport = ["base64", "nom"]
+file-transport = ["dep:uuid", "tokio1_crate?/fs", "tokio1_crate?/io-util"]
+file-transport-envelope = ["serde", "dep:serde_json", "file-transport"]
+sendmail-transport = ["tokio1_crate?/process", "tokio1_crate?/io-util", "async-std?/unstable"]
+smtp-transport = ["dep:base64", "dep:nom", "dep:socket2", "dep:url", "dep:percent-encoding", "tokio1_crate?/rt", "tokio1_crate?/time", "tokio1_crate?/net"]
 
-rustls-tls = ["webpki", "webpki-roots", "rustls"]
+pool = ["dep:futures-util"]
+
+rustls-tls = ["dep:webpki-roots", "dep:rustls", "dep:rustls-pemfile", "dep:rustls-pki-types"]
+
+boring-tls = ["dep:boring"]
 
 # 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"]
-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"]
+async-std1 = ["dep:async-std", "dep:async-trait", "dep:futures-io", "dep:futures-util"]
+async-std1-rustls-tls = ["async-std1", "rustls-tls", "dep:futures-rustls"]
+tokio1 = ["dep:tokio1_crate", "dep:async-trait", "dep:futures-io", "dep:futures-util"]
+tokio1-native-tls = ["tokio1", "native-tls", "dep:tokio1_native_tls_crate"]
+tokio1-rustls-tls = ["tokio1", "rustls-tls", "dep:tokio1_rustls"]
+tokio1-boring-tls = ["tokio1", "boring-tls", "dep:tokio1_boring"]
+
+dkim = ["dep:base64", "dep:sha2", "dep:rsa", "dep:ed25519-dalek"]
+
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(lettre_ignore_tls_mismatch)'] }
 
 [package.metadata.docs.rs]
 all-features = true
-rustdoc-args = ["--cfg", "docsrs"]
+rustdoc-args = ["--cfg", "docsrs", "--cfg", "lettre_ignore_tls_mismatch"]
+
+[[example]]
+name = "autoconfigure"
+required-features = ["smtp-transport", "native-tls"]
 
 [[example]]
 name = "basic_html"

LICENSE

@@ -1,5 +1,5 @@
-Copyright (c) 2014-2020 Alexis Mousset <contact@amousset.me>
-Copyright (c) 2019-2020 Paolo Barbolini <paolo@paolo565.org>
+Copyright (c) 2014-2024 Alexis Mousset <contact@amousset.me>
+Copyright (c) 2019-2024 Paolo Barbolini <paolo@paolo565.org>
 Copyright (c) 2018 K. <kayo@illumium.org>
 
 Permission is hereby granted, free of charge, to any

README.md

@@ -28,27 +28,14 @@
 </div>
 
 <div align="center">
-  <a href="https://deps.rs/crate/lettre/0.10.0-rc.1">
-    <img src="https://deps.rs/crate/lettre/0.10.0-rc.1/status.svg"
+  <a href="https://deps.rs/crate/lettre/0.11.9">
+    <img src="https://deps.rs/crate/lettre/0.11.9/status.svg"
       alt="dependency status" />
   </a>
 </div>
 
 ---
 
-**NOTE**: this readme refers to the 0.10 version of lettre, which is
-in release candidate state. Use the [`v0.9.x`](https://github.com/lettre/lettre/tree/v0.9.x)
-branch for the previous stable release.
-
-0.10 is already widely used and is already thought to be more reliable than 0.9, so it should generally be used
-for new projects.
-
-We'd love to hear your feedback about 0.10 design and APIs before final release!
-Start a [discussion](https://github.com/lettre/lettre/discussions) in the repository, whether for
-feedback or if you need help or advice using or upgrading lettre 0.10.
-
----
-
 ## Features
 
 Lettre provides the following features:
@@ -63,50 +50,79 @@ Lettre does not provide (for now):
 
 * Email parsing
 
+## Supported Rust Versions
+
+Lettre supports all Rust versions released in the last 6 months. At the time of writing
+the minimum supported Rust version is 1.70, but this could change at any time either from
+one of our dependencies bumping their MSRV or by a new patch release of lettre.
+
 ## Example
 
-This library requires Rust 1.46 or newer.
+This library requires Rust 1.70 or newer.
 To use this library, add the following to your `Cargo.toml`:
 
-
 ```toml
 [dependencies]
-lettre = "0.10.0-rc.1"
+lettre = "0.11"
 ```
 
 ```rust,no_run
+use lettre::message::header::ContentType;
 use lettre::transport::smtp::authentication::Credentials;
 use lettre::{Message, SmtpTransport, Transport};
 
-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();
+fn main() {
+    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")
+        .header(ContentType::TEXT_PLAIN)
+        .body(String::from("Be happy!"))
+        .unwrap();
 
-let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
+    let creds = Credentials::new("smtp_username".to_owned(), "smtp_password".to_owned());
 
-// Open a remote connection to gmail
-let mailer = SmtpTransport::relay("smtp.gmail.com")
-    .unwrap()
-    .credentials(creds)
-    .build();
+    // Open a remote connection to gmail
+    let mailer = SmtpTransport::relay("smtp.gmail.com")
+        .unwrap()
+        .credentials(creds)
+        .build();
 
-// Send the email
-match mailer.send(&email) {
-    Ok(_) => println!("Email sent successfully!"),
-    Err(e) => panic!("Could not send email: {:?}", e),
+    // Send the email
+    match mailer.send(&email) {
+        Ok(_) => println!("Email sent successfully!"),
+        Err(e) => panic!("Could not send email: {e:?}"),
+    }
 }
 ```
 
+## Not sure of which connect options to use?
+
+Clone the lettre git repository and run the following command (replacing `SMTP_HOST` with your SMTP server's hostname)
+
+```shell
+cargo run --example autoconfigure SMTP_HOST
+```
+
 ## Testing
 
-The `lettre` tests require an open mail server listening locally on port 2525 and the `sendmail` command.
+The `lettre` tests require an open mail server listening locally on port 2525 and the `sendmail` command. If you have python installed 
+such a server can be launched with `python -m smtpd -n -c DebuggingServer 127.0.0.1:2525`
 
 Alternatively only unit tests can be run by doing `cargo test --lib`.
 
+## Troubleshooting
+
+These are general steps to be followed when troubleshooting SMTP related issues.
+
+- Ensure basic connectivity, ensure requisite ports are open and daemons are listening.
+- Confirm that your service provider allows traffic on the ports being used for mail transfer.
+- Check SMTP relay authentication and configuration.
+- Validate your DNS records. (DMARC, SPF, DKIM, MX)
+- Verify your SSL/TLS certificates are setup properly.
+- Investigate if filtering, formatting, or filesize limits are causing messages to be lost, delayed, or blocked by relays or remote hosts.
+
 ## Code of conduct
 
 Anyone who interacts with Lettre in any space, including but not limited to

SECURITY.md

@@ -2,7 +2,7 @@
 
 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
-should not be reported via the public Github Issue tracker.
+should not be reported via the public GitHub Issue tracker.
 
 ## Security advisories
 

benches/mailbox_parsing.rs

@@ -0,0 +1,27 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use lettre::message::{Mailbox, Mailboxes};
+
+fn bench_parse_single(mailbox: &str) {
+    assert!(mailbox.parse::<Mailbox>().is_ok());
+}
+
+fn bench_parse_multiple(mailboxes: &str) {
+    assert!(mailboxes.parse::<Mailboxes>().is_ok());
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    c.bench_function("parse single mailbox", |b| {
+        b.iter(|| bench_parse_single(black_box("\"Benchmark test\" <test@mail.local>")))
+    });
+
+    c.bench_function("parse multiple mailboxes", |b| {
+        b.iter(|| {
+            bench_parse_multiple(black_box(
+                "\"Benchmark test\" <test@mail.local>, Test <test@mail.local>, <test@mail.local>, test@mail.local",
+            ))
+        })
+    });
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

examples/asyncstd1_smtp_starttls.rs

@@ -1,6 +1,6 @@
 use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncStd1Executor,
-    AsyncTransport, Message,
+    message::header::ContentType, transport::smtp::authentication::Credentials, AsyncSmtpTransport,
+    AsyncStd1Executor, AsyncTransport, Message,
 };
 
 #[async_std::main]
@@ -12,10 +12,11 @@ async fn main() {
         .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
         .to("Hei <hei@domain.tld>".parse().unwrap())
         .subject("Happy new async year")
+        .header(ContentType::TEXT_PLAIN)
         .body(String::from("Be happy with async!"))
         .unwrap();
 
-    let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
+    let creds = Credentials::new("smtp_username".to_owned(), "smtp_password".to_owned());
 
     // Open a remote connection to gmail using STARTTLS
     let mailer: AsyncSmtpTransport<AsyncStd1Executor> =
@@ -27,6 +28,6 @@ async fn main() {
     // Send the email
     match mailer.send(email).await {
         Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
+        Err(e) => panic!("Could not send email: {e:?}"),
     }
 }

examples/asyncstd1_smtp_tls.rs

@@ -1,6 +1,6 @@
 use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncStd1Executor,
-    AsyncTransport, Message,
+    message::header::ContentType, transport::smtp::authentication::Credentials, AsyncSmtpTransport,
+    AsyncStd1Executor, AsyncTransport, Message,
 };
 
 #[async_std::main]
@@ -12,10 +12,11 @@ async fn main() {
         .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
         .to("Hei <hei@domain.tld>".parse().unwrap())
         .subject("Happy new async year")
+        .header(ContentType::TEXT_PLAIN)
         .body(String::from("Be happy with async!"))
         .unwrap();
 
-    let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
+    let creds = Credentials::new("smtp_username".to_owned(), "smtp_password".to_owned());
 
     // Open a remote connection to gmail
     let mailer: AsyncSmtpTransport<AsyncStd1Executor> =
@@ -27,6 +28,6 @@ async fn main() {
     // Send the email
     match mailer.send(email).await {
         Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
+        Err(e) => panic!("Could not send email: {e:?}"),
     }
 }

examples/autoconfigure.rs

@@ -0,0 +1,93 @@
+use std::{env, process, time::Duration};
+
+use lettre::SmtpTransport;
+
+fn main() {
+    tracing_subscriber::fmt::init();
+
+    let smtp_host = match env::args().nth(1) {
+        Some(smtp_host) => smtp_host,
+        None => {
+            println!("Please provide the SMTP host as the first argument to this command");
+            process::exit(1);
+        }
+    };
+
+    // TLS wrapped connection
+    {
+        tracing::info!(
+            "Trying to establish a TLS wrapped connection to {}",
+            smtp_host
+        );
+
+        let transport = SmtpTransport::relay(&smtp_host)
+            .expect("build SmtpTransport::relay")
+            .timeout(Some(Duration::from_secs(10)))
+            .build();
+        match transport.test_connection() {
+            Ok(true) => {
+                tracing::info!("Successfully connected to {} via a TLS wrapped connection (SmtpTransport::relay). This is the fastest option available for connecting to an SMTP server", smtp_host);
+            }
+            Ok(false) => {
+                tracing::error!("Couldn't connect to {} via a TLS wrapped connection. No more information is available", smtp_host);
+            }
+            Err(err) => {
+                tracing::error!(err = %err, "Couldn't connect to {} via a TLS wrapped connection", smtp_host);
+            }
+        }
+    }
+
+    println!();
+
+    // Plaintext connection which MUST then successfully upgrade to TLS via STARTTLS
+    {
+        tracing::info!("Trying to establish a plaintext connection to {} and then upgrading it via the SMTP STARTTLS extension", smtp_host);
+
+        let transport = SmtpTransport::starttls_relay(&smtp_host)
+            .expect("build SmtpTransport::starttls_relay")
+            .timeout(Some(Duration::from_secs(10)))
+            .build();
+        match transport.test_connection() {
+            Ok(true) => {
+                tracing::info!("Successfully connected to {} via a plaintext connection which then got upgraded to TLS via the SMTP STARTTLS extension (SmtpTransport::starttls_relay). This is the second best option after the previous TLS wrapped option", smtp_host);
+            }
+            Ok(false) => {
+                tracing::error!(
+                    "Couldn't connect to {} via STARTTLS. No more information is available",
+                    smtp_host
+                );
+            }
+            Err(err) => {
+                tracing::error!(err = %err, "Couldn't connect to {} via STARTTLS", smtp_host);
+            }
+        }
+    }
+
+    println!();
+
+    // Plaintext connection (very insecure)
+    {
+        tracing::info!(
+            "Trying to establish a plaintext connection to {}",
+            smtp_host
+        );
+
+        let transport = SmtpTransport::builder_dangerous(&smtp_host)
+            .timeout(Some(Duration::from_secs(10)))
+            .build();
+        match transport.test_connection() {
+            Ok(true) => {
+                tracing::info!("Successfully connected to {} via a plaintext connection. This option is very insecure and shouldn't be used on the public internet (SmtpTransport::builder_dangerous)", smtp_host);
+            }
+            Ok(false) => {
+                tracing::error!(
+                    "Couldn't connect to {} via a plaintext connection. No more information is available",
+                    smtp_host
+                );
+            }
+            Err(err) => {
+                tracing::error!(err = %err, "Couldn't connect to {} via a plaintext connection", smtp_host);
+            }
+        }
+    }
+}

examples/smtp.rs

@@ -1,4 +1,4 @@
-use lettre::{Message, SmtpTransport, Transport};
+use lettre::{message::header::ContentType, Message, SmtpTransport, Transport};
 
 fn main() {
     tracing_subscriber::fmt::init();
@@ -8,6 +8,7 @@ fn main() {
         .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
         .to("Hei <hei@domain.tld>".parse().unwrap())
         .subject("Happy new year")
+        .header(ContentType::TEXT_PLAIN)
         .body(String::from("Be happy!"))
         .unwrap();
 
@@ -17,6 +18,6 @@ fn main() {
     // Send the email
     match mailer.send(&email) {
         Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
+        Err(e) => panic!("Could not send email: {e:?}"),
     }
 }

examples/smtp_selfsigned.rs

@@ -1,6 +1,7 @@
 use std::fs;
 
 use lettre::{
+    message::header::ContentType,
     transport::smtp::{
         authentication::Credentials,
         client::{Certificate, Tls, TlsParameters},
@@ -16,18 +17,19 @@ fn main() {
         .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
         .to("Hei <hei@domain.tld>".parse().unwrap())
         .subject("Happy new year")
+        .header(ContentType::TEXT_PLAIN)
         .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())
+    let tls = TlsParameters::builder("smtp.server.com".to_owned())
         .add_root_certificate(cert)
         .build()
         .unwrap();
 
-    let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
+    let creds = Credentials::new("smtp_username".to_owned(), "smtp_password".to_owned());
 
     // Open a remote connection to the smtp server
     let mailer = SmtpTransport::builder_dangerous("smtp.server.com")
@@ -39,6 +41,6 @@ fn main() {
     // Send the email
     match mailer.send(&email) {
         Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
+        Err(e) => panic!("Could not send email: {e:?}"),
     }
 }

examples/smtp_starttls.rs

@@ -1,4 +1,7 @@
-use lettre::{transport::smtp::authentication::Credentials, Message, SmtpTransport, Transport};
+use lettre::{
+    message::header::ContentType, transport::smtp::authentication::Credentials, Message,
+    SmtpTransport, Transport,
+};
 
 fn main() {
     tracing_subscriber::fmt::init();
@@ -8,10 +11,11 @@ fn main() {
         .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
         .to("Hei <hei@domain.tld>".parse().unwrap())
         .subject("Happy new year")
+        .header(ContentType::TEXT_PLAIN)
         .body(String::from("Be happy!"))
         .unwrap();
 
-    let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
+    let creds = Credentials::new("smtp_username".to_owned(), "smtp_password".to_owned());
 
     // Open a remote connection to gmail using STARTTLS
     let mailer = SmtpTransport::starttls_relay("smtp.gmail.com")
@@ -22,6 +26,6 @@ fn main() {
     // Send the email
     match mailer.send(&email) {
         Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
+        Err(e) => panic!("Could not send email: {e:?}"),
     }
 }

examples/smtp_tls.rs

@@ -1,4 +1,7 @@
-use lettre::{transport::smtp::authentication::Credentials, Message, SmtpTransport, Transport};
+use lettre::{
+    message::header::ContentType, transport::smtp::authentication::Credentials, Message,
+    SmtpTransport, Transport,
+};
 
 fn main() {
     tracing_subscriber::fmt::init();
@@ -8,10 +11,11 @@ fn main() {
         .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
         .to("Hei <hei@domain.tld>".parse().unwrap())
         .subject("Happy new year")
+        .header(ContentType::TEXT_PLAIN)
         .body(String::from("Be happy!"))
         .unwrap();
 
-    let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
+    let creds = Credentials::new("smtp_username".to_owned(), "smtp_password".to_owned());
 
     // Open a remote connection to gmail
     let mailer = SmtpTransport::relay("smtp.gmail.com")
@@ -22,6 +26,6 @@ fn main() {
     // Send the email
     match mailer.send(&email) {
         Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
+        Err(e) => panic!("Could not send email: {e:?}"),
     }
 }

examples/tokio1_smtp_starttls.rs

@@ -1,12 +1,11 @@
 // 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,
+    message::header::ContentType, transport::smtp::authentication::Credentials, AsyncSmtpTransport,
+    AsyncTransport, Message, Tokio1Executor,
 };
+use tokio1_crate as tokio;
 
 #[tokio::main]
 async fn main() {
@@ -17,10 +16,11 @@ async fn main() {
         .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
         .to("Hei <hei@domain.tld>".parse().unwrap())
         .subject("Happy new async year")
+        .header(ContentType::TEXT_PLAIN)
         .body(String::from("Be happy with async!"))
         .unwrap();
 
-    let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
+    let creds = Credentials::new("smtp_username".to_owned(), "smtp_password".to_owned());
 
     // Open a remote connection to gmail using STARTTLS
     let mailer: AsyncSmtpTransport<Tokio1Executor> =
@@ -32,6 +32,6 @@ async fn main() {
     // Send the email
     match mailer.send(email).await {
         Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
+        Err(e) => panic!("Could not send email: {e:?}"),
     }
 }

examples/tokio1_smtp_tls.rs

@@ -1,12 +1,11 @@
 // 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,
+    message::header::ContentType, transport::smtp::authentication::Credentials, AsyncSmtpTransport,
+    AsyncTransport, Message, Tokio1Executor,
 };
+use tokio1_crate as tokio;
 
 #[tokio::main]
 async fn main() {
@@ -17,10 +16,11 @@ async fn main() {
         .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
         .to("Hei <hei@domain.tld>".parse().unwrap())
         .subject("Happy new async year")
+        .header(ContentType::TEXT_PLAIN)
         .body(String::from("Be happy with async!"))
         .unwrap();
 
-    let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
+    let creds = Credentials::new("smtp_username".to_owned(), "smtp_password".to_owned());
 
     // Open a remote connection to gmail
     let mailer: AsyncSmtpTransport<Tokio1Executor> =
@@ -32,6 +32,6 @@ async fn main() {
     // Send the email
     match mailer.send(email).await {
         Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
+        Err(e) => panic!("Could not send email: {e:?}"),
     }
 }

rustfmt.toml

@@ -0,0 +1,3 @@
+format_code_in_doc_comments = true
+imports_granularity = "Crate"
+group_imports = "StdExternalCrate"

src/address/envelope.rs

@@ -1,6 +1,3 @@
-#[cfg(feature = "builder")]
-use std::convert::TryFrom;
-
 use super::Address;
 #[cfg(feature = "builder")]
 use crate::message::header::{self, Headers};
@@ -17,11 +14,71 @@ pub struct Envelope {
     /// The envelope recipient's addresses
     ///
     /// This can not be empty.
+    #[cfg_attr(
+        feature = "serde",
+        serde(deserialize_with = "serde_forward_path::deserialize")
+    )]
     forward_path: Vec<Address>,
     /// The envelope sender address
     reverse_path: Option<Address>,
 }
 
+/// just like the default implementation to deserialize `Vec<Address>` but it
+/// forbids **de**serializing empty lists
+#[cfg(feature = "serde")]
+mod serde_forward_path {
+    use super::Address;
+    /// dummy type required for serde
+    /// see example: https://serde.rs/deserialize-map.html
+    struct CustomVisitor;
+    impl<'de> serde::de::Visitor<'de> for CustomVisitor {
+        type Value = Vec<Address>;
+
+        fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            formatter.write_str("a non-empty list of recipient addresses")
+        }
+
+        fn visit_seq<S>(self, mut access: S) -> Result<Self::Value, S::Error>
+        where
+            S: serde::de::SeqAccess<'de>,
+        {
+            let mut seq: Vec<Address> = Vec::with_capacity(access.size_hint().unwrap_or(0));
+            while let Some(key) = access.next_element()? {
+                seq.push(key);
+            }
+            if seq.is_empty() {
+                Err(serde::de::Error::invalid_length(seq.len(), &self))
+            } else {
+                Ok(seq)
+            }
+        }
+    }
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<Address>, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_seq(CustomVisitor {})
+    }
+
+    #[cfg(test)]
+    mod tests {
+        #[test]
+        fn deserializing_empty_recipient_list_returns_error() {
+            assert!(
+                serde_json::from_str::<crate::address::Envelope>(r#"{"forward_path": []}"#)
+                    .is_err()
+            );
+        }
+        #[test]
+        fn deserializing_non_empty_recipient_list_is_ok() {
+            serde_json::from_str::<crate::address::Envelope>(
+                r#"{ "forward_path": [ {"user":"foo", "domain":"example.com"} ] }"#,
+            )
+            .unwrap();
+        }
+    }
+}
+
 impl Envelope {
     /// Creates a new envelope, which may fail if `to` is empty.
     ///

src/address/types.rs

@@ -1,10 +1,6 @@
 //! Representation of an email address
 
-use idna::domain_to_ascii;
-use once_cell::sync::Lazy;
-use regex::Regex;
 use std::{
-    convert::{TryFrom, TryInto},
     error::Error,
     ffi::OsStr,
     fmt::{Display, Formatter, Result as FmtResult},
@@ -12,11 +8,14 @@ use std::{
     str::FromStr,
 };
 
+use email_address::EmailAddress;
+use idna::domain_to_ascii;
+
 /// Represents an email address with a user and a domain name.
 ///
 /// This type contains email in canonical form (_user@domain.tld_).
 ///
-/// **NOTE**: Enable feature "serde" to be able serialize/deserialize it using [serde](https://serde.rs/).
+/// **NOTE**: Enable feature "serde" to be able to serialize/deserialize it using [serde](https://serde.rs/).
 ///
 /// # Examples
 ///
@@ -55,20 +54,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.
     ///
@@ -126,7 +111,7 @@ impl Address {
     }
 
     pub(super) fn check_user(user: &str) -> Result<(), AddressError> {
-        if USER_RE.is_match(user) {
+        if EmailAddress::is_valid_local_part(user) {
             Ok(())
         } else {
             Err(AddressError::InvalidUser)
@@ -142,16 +127,19 @@ impl Address {
     }
 
     fn check_domain_ascii(domain: &str) -> Result<(), AddressError> {
-        if DOMAIN_RE.is_match(domain) {
+        // Domain
+        if EmailAddress::is_valid_domain(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(());
-                }
-            }
+        // IP
+        let ip = domain
+            .strip_prefix('[')
+            .and_then(|ip| ip.strip_suffix(']'))
+            .unwrap_or(domain);
+
+        if ip.parse::<IpAddr>().is_ok() {
+            return Ok(());
         }
 
         Err(AddressError::InvalidDomain)
@@ -174,15 +162,10 @@ 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)?;
+        let at_start = check_address(val)?;
         Ok(Address {
             serialized: val.into(),
-            at_start: user.len(),
+            at_start,
         })
     }
 }
@@ -201,7 +184,7 @@ where
         let domain = domain.as_ref();
         Address::check_domain(domain)?;
 
-        let serialized = format!("{}@{}", user, domain);
+        let serialized = format!("{user}@{domain}");
         Ok(Address {
             serialized,
             at_start: user.len(),
@@ -209,6 +192,18 @@ where
     }
 }
 
+impl TryFrom<String> for Address {
+    type Error = AddressError;
+
+    fn try_from(serialized: String) -> Result<Self, AddressError> {
+        let at_start = check_address(&serialized)?;
+        Ok(Address {
+            serialized,
+            at_start,
+        })
+    }
+}
+
 impl AsRef<str> for Address {
     fn as_ref(&self) -> &str {
         &self.serialized
@@ -221,7 +216,18 @@ impl AsRef<OsStr> for Address {
     }
 }
 
-#[derive(Debug, PartialEq, Clone, Copy)]
+fn check_address(val: &str) -> Result<usize, 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(user.len())
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[non_exhaustive]
 /// Errors in email addresses parsing
 pub enum AddressError {
     /// Missing domain or user
@@ -232,6 +238,8 @@ pub enum AddressError {
     InvalidUser,
     /// Invalid email domain
     InvalidDomain,
+    /// Invalid input found
+    InvalidInput,
 }
 
 impl Error for AddressError {}
@@ -243,6 +251,7 @@ impl Display for AddressError {
             AddressError::Unbalanced => f.write_str("Unbalanced angle bracket"),
             AddressError::InvalidUser => f.write_str("Invalid email user"),
             AddressError::InvalidDomain => f.write_str("Invalid email domain"),
+            AddressError::InvalidInput => f.write_str("Invalid input"),
         }
     }
 }
@@ -252,7 +261,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn parse_address() {
+    fn ascii_address() {
         let addr_str = "something@example.com";
         let addr = Address::from_str(addr_str).unwrap();
         let addr2 = Address::new("something", "example.com").unwrap();
@@ -262,4 +271,36 @@ mod tests {
         assert_eq!(addr2.user(), "something");
         assert_eq!(addr2.domain(), "example.com");
     }
+
+    #[test]
+    fn ascii_address_ipv4() {
+        let addr_str = "something@1.1.1.1";
+        let addr = Address::from_str(addr_str).unwrap();
+        let addr2 = Address::new("something", "1.1.1.1").unwrap();
+        assert_eq!(addr, addr2);
+        assert_eq!(addr.user(), "something");
+        assert_eq!(addr.domain(), "1.1.1.1");
+        assert_eq!(addr2.user(), "something");
+        assert_eq!(addr2.domain(), "1.1.1.1");
+    }
+
+    #[test]
+    fn ascii_address_ipv6() {
+        let addr_str = "something@[2606:4700:4700::1111]";
+        let addr = Address::from_str(addr_str).unwrap();
+        let addr2 = Address::new("something", "[2606:4700:4700::1111]").unwrap();
+        assert_eq!(addr, addr2);
+        assert_eq!(addr.user(), "something");
+        assert_eq!(addr.domain(), "[2606:4700:4700::1111]");
+        assert_eq!(addr2.user(), "something");
+        assert_eq!(addr2.domain(), "[2606:4700:4700::1111]");
+    }
+
+    #[test]
+    fn check_parts() {
+        assert!(Address::check_user("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").is_err());
+        assert!(
+            Address::check_domain("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.com").is_err()
+        );
+    }
 }

src/base64.rs

@@ -0,0 +1,12 @@
+use ::base64::{
+    engine::{general_purpose::STANDARD, Engine},
+    DecodeError,
+};
+
+pub(crate) fn encode<T: AsRef<[u8]>>(input: T) -> String {
+    STANDARD.encode(input)
+}
+
+pub(crate) fn decode<T: AsRef<[u8]>>(input: T) -> Result<Vec<u8>, DecodeError> {
+    STANDARD.decode(input)
+}

src/executor.rs

@@ -1,10 +1,16 @@
-use async_trait::async_trait;
-
 use std::fmt::Debug;
+#[cfg(feature = "smtp-transport")]
+use std::future::Future;
 #[cfg(feature = "file-transport")]
 use std::io::Result as IoResult;
 #[cfg(feature = "file-transport")]
 use std::path::Path;
+#[cfg(feature = "smtp-transport")]
+use std::time::Duration;
+
+use async_trait::async_trait;
+#[cfg(all(feature = "smtp-transport", feature = "async-std1"))]
+use futures_util::future::BoxFuture;
 
 #[cfg(all(
     feature = "smtp-transport",
@@ -37,12 +43,29 @@ use crate::transport::smtp::Error;
 /// [`AsyncFileTransport`]: crate::AsyncFileTransport
 #[cfg_attr(docsrs, doc(cfg(any(feature = "tokio1", feature = "async-std1"))))]
 #[async_trait]
-pub trait Executor: Debug + Send + Sync + private::Sealed {
+pub trait Executor: Debug + Send + Sync + 'static + private::Sealed {
+    #[cfg(feature = "smtp-transport")]
+    type Handle: SpawnHandle;
+    #[cfg(feature = "smtp-transport")]
+    type Sleep: Future<Output = ()> + Send + 'static;
+
+    #[doc(hidden)]
+    #[cfg(feature = "smtp-transport")]
+    fn spawn<F>(fut: F) -> Self::Handle
+    where
+        F: Future<Output = ()> + Send + 'static,
+        F::Output: Send + 'static;
+
+    #[doc(hidden)]
+    #[cfg(feature = "smtp-transport")]
+    fn sleep(duration: Duration) -> Self::Sleep;
+
     #[doc(hidden)]
     #[cfg(feature = "smtp-transport")]
     async fn connect(
         hostname: &str,
         port: u16,
+        timeout: Option<Duration>,
         hello_name: &ClientId,
         tls: &Tls,
     ) -> Result<AsyncSmtpConnection, Error>;
@@ -56,6 +79,13 @@ pub trait Executor: Debug + Send + Sync + private::Sealed {
     async fn fs_write(path: &Path, contents: &[u8]) -> IoResult<()>;
 }
 
+#[doc(hidden)]
+#[cfg(feature = "smtp-transport")]
+#[async_trait]
+pub trait SpawnHandle: Debug + Send + Sync + 'static + private::Sealed {
+    async fn shutdown(self);
+}
+
 /// Async [`Executor`] using `tokio` `1.x`
 ///
 /// Used by [`AsyncSmtpTransport`], [`AsyncSendmailTransport`] and [`AsyncFileTransport`]
@@ -74,32 +104,57 @@ pub struct Tokio1Executor;
 #[async_trait]
 #[cfg(feature = "tokio1")]
 impl Executor for Tokio1Executor {
-    #[doc(hidden)]
+    #[cfg(feature = "smtp-transport")]
+    type Handle = tokio1_crate::task::JoinHandle<()>;
+    #[cfg(feature = "smtp-transport")]
+    type Sleep = tokio1_crate::time::Sleep;
+
+    #[cfg(feature = "smtp-transport")]
+    fn spawn<F>(fut: F) -> Self::Handle
+    where
+        F: Future<Output = ()> + Send + 'static,
+        F::Output: Send + 'static,
+    {
+        tokio1_crate::spawn(fut)
+    }
+
+    #[cfg(feature = "smtp-transport")]
+    fn sleep(duration: Duration) -> Self::Sleep {
+        tokio1_crate::time::sleep(duration)
+    }
+
     #[cfg(feature = "smtp-transport")]
     async fn connect(
         hostname: &str,
         port: u16,
+        timeout: Option<Duration>,
         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()),
+            Tls::Wrapper(tls_parameters) => Some(tls_parameters.clone()),
             _ => None,
         };
         #[allow(unused_mut)]
-        let mut conn =
-            AsyncSmtpConnection::connect_tokio1(hostname, port, hello_name, tls_parameters).await?;
+        let mut conn = AsyncSmtpConnection::connect_tokio1(
+            (hostname, port),
+            timeout,
+            hello_name,
+            tls_parameters,
+            None,
+        )
+        .await?;
 
         #[cfg(any(feature = "tokio1-native-tls", feature = "tokio1-rustls-tls"))]
         match tls {
-            Tls::Opportunistic(ref tls_parameters) => {
+            Tls::Opportunistic(tls_parameters) => {
                 if conn.can_starttls() {
                     conn.starttls(tls_parameters.clone(), hello_name).await?;
                 }
             }
-            Tls::Required(ref tls_parameters) => {
+            Tls::Required(tls_parameters) => {
                 conn.starttls(tls_parameters.clone(), hello_name).await?;
             }
             _ => (),
@@ -108,19 +163,25 @@ impl Executor for Tokio1Executor {
         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
     }
 }
 
+#[cfg(all(feature = "smtp-transport", feature = "tokio1"))]
+#[async_trait]
+impl SpawnHandle for tokio1_crate::task::JoinHandle<()> {
+    async fn shutdown(self) {
+        self.abort();
+    }
+}
+
 /// Async [`Executor`] using `async-std` `1.x`
 ///
 /// Used by [`AsyncSmtpTransport`], [`AsyncSendmailTransport`] and [`AsyncFileTransport`]
@@ -139,33 +200,57 @@ pub struct AsyncStd1Executor;
 #[async_trait]
 #[cfg(feature = "async-std1")]
 impl Executor for AsyncStd1Executor {
-    #[doc(hidden)]
+    #[cfg(feature = "smtp-transport")]
+    type Handle = async_std::task::JoinHandle<()>;
+    #[cfg(feature = "smtp-transport")]
+    type Sleep = BoxFuture<'static, ()>;
+
+    #[cfg(feature = "smtp-transport")]
+    fn spawn<F>(fut: F) -> Self::Handle
+    where
+        F: Future<Output = ()> + Send + 'static,
+        F::Output: Send + 'static,
+    {
+        async_std::task::spawn(fut)
+    }
+
+    #[cfg(feature = "smtp-transport")]
+    fn sleep(duration: Duration) -> Self::Sleep {
+        let fut = async_std::task::sleep(duration);
+        Box::pin(fut)
+    }
+
     #[cfg(feature = "smtp-transport")]
     async fn connect(
         hostname: &str,
         port: u16,
+        timeout: Option<Duration>,
         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()),
+            #[cfg(feature = "async-std1-rustls-tls")]
+            Tls::Wrapper(tls_parameters) => Some(tls_parameters.clone()),
             _ => None,
         };
         #[allow(unused_mut)]
-        let mut conn =
-            AsyncSmtpConnection::connect_asyncstd1(hostname, port, hello_name, tls_parameters)
-                .await?;
+        let mut conn = AsyncSmtpConnection::connect_asyncstd1(
+            (hostname, port),
+            timeout,
+            hello_name,
+            tls_parameters,
+        )
+        .await?;
 
-        #[cfg(any(feature = "async-std1-native-tls", feature = "async-std1-rustls-tls"))]
+        #[cfg(feature = "async-std1-rustls-tls")]
         match tls {
-            Tls::Opportunistic(ref tls_parameters) => {
+            Tls::Opportunistic(tls_parameters) => {
                 if conn.can_starttls() {
                     conn.starttls(tls_parameters.clone(), hello_name).await?;
                 }
             }
-            Tls::Required(ref tls_parameters) => {
+            Tls::Required(tls_parameters) => {
                 conn.starttls(tls_parameters.clone(), hello_name).await?;
             }
             _ => (),
@@ -174,27 +259,37 @@ impl Executor for AsyncStd1Executor {
         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::*;
+#[cfg(all(feature = "smtp-transport", feature = "async-std1"))]
+#[async_trait]
+impl SpawnHandle for async_std::task::JoinHandle<()> {
+    async fn shutdown(self) {
+        self.cancel().await;
+    }
+}
 
+mod private {
     pub trait Sealed {}
 
     #[cfg(feature = "tokio1")]
-    impl Sealed for Tokio1Executor {}
+    impl Sealed for super::Tokio1Executor {}
 
     #[cfg(feature = "async-std1")]
-    impl Sealed for AsyncStd1Executor {}
+    impl Sealed for super::AsyncStd1Executor {}
+
+    #[cfg(all(feature = "smtp-transport", feature = "tokio1"))]
+    impl Sealed for tokio1_crate::task::JoinHandle<()> {}
+
+    #[cfg(all(feature = "smtp-transport", feature = "async-std1"))]
+    impl Sealed for async_std::task::JoinHandle<()> {}
 }

src/lib.rs

@@ -6,7 +6,7 @@
 //! * Secure defaults
 //! * Async support
 //!
-//! Lettre requires Rust 1.46 or newer.
+//! Lettre requires Rust 1.70 or newer.
 //!
 //! ## Features
 //!
@@ -27,7 +27,7 @@
 //! _Send emails using [`SMTP`]_
 //!
 //! * **smtp-transport** 📫: Enable the SMTP transport
-//! * **r2d2** 📫: Connection pool for SMTP transport
+//! * **pool** 📫: 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
@@ -41,6 +41,15 @@
 //!
 //! NOTE: native-tls isn't supported with `async-std`
 //!
+//! #### SMTP over TLS via the boring crate (Boring TLS)
+//!
+//! _Secure SMTP connections using TLS from the `boring-tls` crate_
+//!
+//! * **boring-tls**: TLS support for the synchronous version of the API
+//! * **tokio1-boring-tls**: TLS support for the `tokio1` async version of the API
+//!
+//! NOTE: boring-tls isn't supported with `async-std`
+//!
 //! #### SMTP over TLS via the rustls crate
 //!
 //! _Secure SMTP connections using TLS from the `rustls-tls` crate_
@@ -84,18 +93,23 @@
 //!
 //! * **serde**: Serialization/Deserialization of entities
 //! * **tracing**: Logging using the `tracing` crate
+//! * **mime03**: Allow creating a [`ContentType`] from an existing [mime 0.3] `Mime` struct
+//! * **dkim**: Add support for signing email with DKIM
 //!
 //! [`SMTP`]: crate::transport::smtp
 //! [`sendmail`]: crate::transport::sendmail
 //! [`file`]: crate::transport::file
+//! [`ContentType`]: crate::message::header::ContentType
 //! [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 1.x]: https://docs.rs/tokio/1
 //! [async-std 1.x]: https://docs.rs/async-std/1
+//! [mime 0.3]: https://docs.rs/mime/0.3
+//! [DKIM]: https://datatracker.ietf.org/doc/html/rfc6376
 
-#![doc(html_root_url = "https://docs.rs/crate/lettre/0.10.0-rc.1")]
+#![doc(html_root_url = "https://docs.rs/crate/lettre/0.11.9")]
 #![doc(html_favicon_url = "https://lettre.rs/favicon.ico")]
 #![doc(html_logo_url = "https://avatars0.githubusercontent.com/u/15113230?v=4")]
 #![forbid(unsafe_code)]
@@ -105,11 +119,80 @@
     trivial_numeric_casts,
     unstable_features,
     unused_import_braces,
-    rust_2018_idioms
+    rust_2018_idioms,
+    clippy::string_add,
+    clippy::string_add_assign,
+    clippy::clone_on_ref_ptr,
+    clippy::verbose_file_reads,
+    clippy::unnecessary_self_imports,
+    clippy::string_to_string,
+    clippy::mem_forget,
+    clippy::cast_lossless,
+    clippy::inefficient_to_string,
+    clippy::inline_always,
+    clippy::linkedlist,
+    clippy::macro_use_imports,
+    clippy::manual_assert,
+    clippy::unnecessary_join,
+    clippy::wildcard_imports,
+    clippy::str_to_string,
+    clippy::empty_structs_with_brackets,
+    clippy::zero_sized_map_values
 )]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 
+#[cfg(not(lettre_ignore_tls_mismatch))]
+mod compiletime_checks {
+    #[cfg(all(feature = "native-tls", feature = "boring-tls"))]
+    compile_error!("feature \"native-tls\" and feature \"boring-tls\" cannot be enabled at the same time, otherwise
+    the executable will fail to link.");
+
+    #[cfg(all(
+        feature = "tokio1",
+        feature = "native-tls",
+        not(feature = "tokio1-native-tls")
+    ))]
+    compile_error!("Lettre is being built with the `tokio1` and the `native-tls` features, but the `tokio1-native-tls` feature hasn't been turned on.
+    If you were trying to opt into `rustls-tls` and did not activate `native-tls`, disable the default-features of lettre in `Cargo.toml` and manually add the required features.
+    Make sure to apply the same to any of your crate dependencies that use the `lettre` crate.");
+
+    #[cfg(all(
+        feature = "tokio1",
+        feature = "rustls-tls",
+        not(feature = "tokio1-rustls-tls")
+    ))]
+    compile_error!("Lettre is being built with the `tokio1` and the `rustls-tls` features, but the `tokio1-rustls-tls` feature hasn't been turned on.
+    If you'd like to use `native-tls` make sure that the `rustls-tls` feature hasn't been enabled by mistake.
+    Make sure to apply the same to any of your crate dependencies that use the `lettre` crate.");
+
+    #[cfg(all(
+        feature = "tokio1",
+        feature = "boring-tls",
+        not(feature = "tokio1-boring-tls")
+    ))]
+    compile_error!("Lettre is being built with the `tokio1` and the `boring-tls` features, but the `tokio1-boring-tls` feature hasn't been turned on.
+    If you'd like to use `boring-tls` make sure that the `rustls-tls` feature hasn't been enabled by mistake.
+    Make sure to apply the same to any of your crate dependencies that use the `lettre` crate.");
+
+    #[cfg(all(feature = "async-std1", feature = "native-tls",))]
+    compile_error!("Lettre is being built with the `async-std1` and the `native-tls` features, but the async-std integration doesn't support native-tls yet.
+If you'd like to work on the issue please take a look at https://github.com/lettre/lettre/issues/576.
+If you were trying to opt into `rustls-tls` and did not activate `native-tls`, disable the default-features of lettre in `Cargo.toml` and manually add the required features.
+Make sure to apply the same to any of your crate dependencies that use the `lettre` crate.");
+
+    #[cfg(all(
+        feature = "async-std1",
+        feature = "rustls-tls",
+        not(feature = "async-std1-rustls-tls")
+    ))]
+    compile_error!("Lettre is being built with the `async-std1` and the `rustls-tls` features, but the `async-std1-rustls-tls` feature hasn't been turned on.
+If you'd like to use `native-tls` make sure that the `rustls-tls` hasn't been enabled by mistake.
+Make sure to apply the same to any of your crate dependencies that use the `lettre` crate.");
+}
+
 pub mod address;
+#[cfg(any(feature = "smtp-transport", feature = "dkim"))]
+mod base64;
 pub mod error;
 #[cfg(any(feature = "tokio1", feature = "async-std1"))]
 mod executor;
@@ -118,13 +201,15 @@ mod executor;
 pub mod message;
 pub mod transport;
 
+use std::error::Error as StdError;
+
 #[cfg(feature = "async-std1")]
 pub use self::executor::AsyncStd1Executor;
-#[cfg(all(any(feature = "tokio1", feature = "async-std1")))]
+#[cfg(any(feature = "tokio1", feature = "async-std1"))]
 pub use self::executor::Executor;
 #[cfg(feature = "tokio1")]
 pub use self::executor::Tokio1Executor;
-#[cfg(all(any(feature = "tokio1", feature = "async-std1")))]
+#[cfg(any(feature = "tokio1", feature = "async-std1"))]
 #[doc(inline)]
 pub use self::transport::AsyncTransport;
 pub use crate::address::Address;
@@ -154,21 +239,17 @@ pub use crate::transport::sendmail::SendmailTransport;
     any(feature = "tokio1", feature = "async-std1")
 ))]
 pub use crate::transport::smtp::AsyncSmtpTransport;
+#[cfg(feature = "smtp-transport")]
+pub use crate::transport::smtp::SmtpTransport;
 #[doc(inline)]
 pub use crate::transport::Transport;
 use crate::{address::Envelope, error::Error};
 
-#[cfg(feature = "smtp-transport")]
-pub use crate::transport::smtp::SmtpTransport;
-use std::error::Error as StdError;
-
 pub(crate) type BoxError = Box<dyn StdError + Send + Sync>;
 
 #[cfg(test)]
 #[cfg(feature = "builder")]
 mod test {
-    use std::convert::TryFrom;
-
     use super::*;
     use crate::message::{header, header::Headers, Mailbox, Mailboxes};
 

src/message/attachment.rs

@@ -13,28 +13,82 @@ pub struct Attachment {
 
 #[derive(Clone)]
 enum Disposition {
-    /// file name
+    /// File name
     Attached(String),
-    /// content id
+    /// Content id
     Inline(String),
 }
 
 impl Attachment {
-    /// Creates a new attachment
+    /// Create a new attachment
+    ///
+    /// This attachment will be displayed as a normal attachment,
+    /// with the chosen `filename` appearing as the file name.
+    ///
+    /// ```rust
+    /// # use std::error::Error;
+    /// use std::fs;
+    ///
+    /// use lettre::message::{header::ContentType, Attachment};
+    ///
+    /// # fn main() -> Result<(), Box<dyn Error>> {
+    /// let filename = String::from("invoice.pdf");
+    /// # if false {
+    /// let filebody = fs::read("invoice.pdf")?;
+    /// # }
+    /// # let filebody = fs::read("docs/lettre.png")?;
+    /// let content_type = ContentType::parse("application/pdf").unwrap();
+    /// let attachment = Attachment::new(filename).body(filebody, content_type);
+    ///
+    /// // The document `attachment` will show up as a normal attachment.
+    /// # Ok(())
+    /// # }
+    /// ```
     pub fn new(filename: String) -> Self {
         Attachment {
             disposition: Disposition::Attached(filename),
         }
     }
 
-    /// Creates a new inline attachment
+    /// Create a new inline attachment
+    ///
+    /// This attachment should be displayed inline into the message
+    /// body:
+    ///
+    /// ```html
+    /// <img src="cid:123">
+    /// ```
+    ///
+    ///
+    /// ```rust
+    /// # use std::error::Error;
+    /// use std::fs;
+    ///
+    /// use lettre::message::{header::ContentType, Attachment};
+    ///
+    /// # fn main() -> Result<(), Box<dyn Error>> {
+    /// let content_id = String::from("123");
+    /// # if false {
+    /// let filebody = fs::read("image.jpg")?;
+    /// # }
+    /// # let filebody = fs::read("docs/lettre.png")?;
+    /// let content_type = ContentType::parse("image/jpeg").unwrap();
+    /// let attachment = Attachment::new_inline(content_id).body(filebody, content_type);
+    ///
+    /// // The image `attachment` will display inline into the email.
+    /// # Ok(())
+    /// # }
+    /// ```
     pub fn new_inline(content_id: String) -> Self {
         Attachment {
             disposition: Disposition::Inline(content_id),
         }
     }
 
-    /// Build the attachment part
+    /// Build the attachment into a [`SinglePart`] which can then be used to build the rest of the email
+    ///
+    /// Look at the [Complex MIME body example](crate::message#complex-mime-body)
+    /// to see how [`SinglePart`] can be put into the email.
     pub fn body<T: IntoBody>(self, content: T, content_type: ContentType) -> SinglePart {
         let mut builder = SinglePart::builder();
         builder = match self.disposition {
@@ -42,7 +96,7 @@ impl Attachment {
                 builder.header(header::ContentDisposition::attachment(&filename))
             }
             Disposition::Inline(content_id) => builder
-                .header(header::ContentId::from(format!("<{}>", content_id)))
+                .header(header::ContentId::from(format!("<{content_id}>")))
                 .header(header::ContentDisposition::inline()),
         };
         builder = builder.header(content_type);

src/message/body.rs

@@ -1,15 +1,11 @@
-use std::{
-    io::{self, Write},
-    mem,
-    ops::Deref,
-};
+use std::{mem, ops::Deref, sync::Arc};
 
 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>,
+    buf: Arc<[u8]>,
     encoding: ContentTransferEncoding,
 }
 
@@ -41,9 +37,9 @@ impl Body {
     pub fn new<B: Into<MaybeString>>(buf: B) -> Self {
         let mut buf: MaybeString = buf.into();
 
-        let encoding = buf.encoding();
+        let encoding = buf.encoding(false);
         buf.encode_crlf();
-        Self::new_impl(buf.into(), encoding)
+        Self::new_impl(Vec::from(buf).into(), encoding)
     }
 
     /// Encode the supplied `buf`, using the provided `encoding`.
@@ -61,12 +57,27 @@ impl Body {
     ) -> Result<Self, Vec<u8>> {
         let mut buf: MaybeString = buf.into();
 
-        if !buf.is_encoding_ok(encoding) {
+        let best_encoding = buf.encoding(true);
+        let ok = match (encoding, best_encoding) {
+            (ContentTransferEncoding::SevenBit, ContentTransferEncoding::SevenBit) => true,
+            (
+                ContentTransferEncoding::EightBit,
+                ContentTransferEncoding::SevenBit | ContentTransferEncoding::EightBit,
+            ) => true,
+            (ContentTransferEncoding::SevenBit | ContentTransferEncoding::EightBit, _) => false,
+            (
+                ContentTransferEncoding::QuotedPrintable
+                | ContentTransferEncoding::Base64
+                | ContentTransferEncoding::Binary,
+                _,
+            ) => true,
+        };
+        if !ok {
             return Err(buf.into());
         }
 
         buf.encode_crlf();
-        Ok(Self::new_impl(buf.into(), encoding))
+        Ok(Self::new_impl(Vec::from(buf).into(), encoding))
     }
 
     /// Builds a new `Body` using a pre-encoded buffer.
@@ -76,11 +87,14 @@ impl Body {
     /// `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 }
+        Self {
+            buf: buf.into(),
+            encoding,
+        }
     }
 
     /// Encodes the supplied `buf` using the provided `encoding`
-    fn new_impl(buf: Vec<u8>, encoding: ContentTransferEncoding) -> Self {
+    fn new_impl(buf: Arc<[u8]>, encoding: ContentTransferEncoding) -> Self {
         match encoding {
             ContentTransferEncoding::SevenBit
             | ContentTransferEncoding::EightBit
@@ -91,36 +105,13 @@ impl Body {
                 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 len = email_encoding::body::base64::encoded_len(buf.len());
 
-                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);
+                let mut out = String::with_capacity(len);
+                email_encoding::body::base64::encode(&buf, &mut out)
+                    .expect("encode body as base64");
 
-                    // 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)
+                Self::dangerous_pre_encoded(out.into_bytes(), ContentTransferEncoding::Base64)
             }
         }
     }
@@ -145,7 +136,16 @@ impl Body {
 
     /// Consumes `Body` and returns the inner `Vec<u8>`
     #[inline]
+    #[deprecated(
+        note = "The inner memory is not stored into `Vec<u8>` anymore. Consider using `into_inner`"
+    )]
     pub fn into_vec(self) -> Vec<u8> {
+        self.buf.to_vec()
+    }
+
+    /// Consumes `Body` and returns the inner `Arc<[u8]>`
+    #[inline]
+    pub fn into_inner(self) -> Arc<[u8]> {
         self.buf
     }
 }
@@ -153,21 +153,20 @@ impl Body {
 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,
+    /// The `binary` encoding is never returned
+    fn encoding(&self, supports_utf8: bool) -> ContentTransferEncoding {
+        use email_encoding::body::Encoding;
+
+        let output = match self {
+            Self::String(s) => Encoding::choose(s.as_str(), supports_utf8),
+            Self::Binary(b) => Encoding::choose(b.as_slice(), supports_utf8),
+        };
+
+        match output {
+            Encoding::SevenBit => ContentTransferEncoding::SevenBit,
+            Encoding::EightBit => ContentTransferEncoding::EightBit,
+            Encoding::QuotedPrintable => ContentTransferEncoding::QuotedPrintable,
+            Encoding::Base64 => ContentTransferEncoding::Base64,
         }
     }
 
@@ -178,18 +177,6 @@ impl MaybeString {
             Self::Binary(_) => {}
         }
     }
-
-    /// Returns `true` if using `encoding` to encode this `MaybeString`
-    /// would result into an invalid encoded body.
-    fn is_encoding_ok(&self, encoding: ContentTransferEncoding) -> bool {
-        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`].
@@ -273,76 +260,9 @@ impl Deref for MaybeString {
     }
 }
 
-/// 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()
-    }
-}
-
 /// In place conversion to CRLF line endings
 fn in_place_crlf_line_endings(string: &mut String) {
-    let indices = find_all_lf_char_indices(&string);
+    let indices = find_all_lf_char_indices(string);
 
     for i in indices {
         // this relies on `indices` being in reverse order
@@ -377,6 +297,8 @@ fn find_all_lf_char_indices(s: &str) -> Vec<usize> {
 
 #[cfg(test)]
 mod test {
+    use pretty_assertions::assert_eq;
+
     use super::{in_place_crlf_line_endings, Body, ContentTransferEncoding};
 
     #[test]
@@ -509,13 +431,10 @@ mod test {
 
     #[test]
     fn quoted_printable_detect() {
-        let encoded = Body::new(String::from("Привет, мир!"));
+        let encoded = Body::new(String::from("Questo messaggio è corto"));
 
         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()
-        );
+        assert_eq!(encoded.as_ref(), b"Questo messaggio =C3=A8 corto");
     }
 
     #[test]
@@ -547,14 +466,17 @@ mod test {
 
     #[test]
     fn quoted_printable_encode_line_wrap() {
-        let encoded = Body::new(String::from("Текст письма в уникоде"));
+        let encoded = Body::new(String::from(
+            "Se lo standard 📬 fosse stato più semplice avremmo finito molto prima.",
+        ));
 
         assert_eq!(encoded.encoding(), ContentTransferEncoding::QuotedPrintable);
+        println!("{}", std::str::from_utf8(encoded.as_ref()).unwrap());
         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"
+                "Se lo standard =F0=9F=93=AC fosse stato pi=C3=B9 semplice avremmo finito mo=\r\n",
+                "lto prima."
             )
             .as_bytes()
         );
@@ -562,27 +484,31 @@ mod test {
 
     #[test]
     fn base64_detect() {
-        let input = Body::new(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+        let input = Body::new(vec![0; 80]);
         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();
+        let encoded =
+            Body::new_with_encoding(vec![0; 80], ContentTransferEncoding::Base64).unwrap();
 
         assert_eq!(encoded.encoding(), ContentTransferEncoding::Base64);
-        assert_eq!(encoded.as_ref(), b"AAECAwQFBgcICQ==");
+        assert_eq!(
+            encoded.as_ref(),
+            concat!(
+                "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\r\n",
+                "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
+            )
+            .as_bytes()
+        );
     }
 
     #[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),
+            [0, 1, 2, 3, 4, 5, 6, 7, 8, 9].repeat(20),
             ContentTransferEncoding::Base64,
         )
         .unwrap();

src/message/dkim.rs

@@ -0,0 +1,616 @@
+use std::{
+    borrow::Cow,
+    error::Error as StdError,
+    fmt::{self, Display},
+    time::SystemTime,
+};
+
+use ed25519_dalek::Signer;
+use rsa::{pkcs1::DecodeRsaPrivateKey, pkcs1v15::Pkcs1v15Sign, RsaPrivateKey};
+use sha2::{Digest, Sha256};
+
+use crate::message::{
+    header::{HeaderName, HeaderValue},
+    Headers, Message,
+};
+
+/// Describe Dkim Canonicalization to apply to either body or headers
+#[derive(Copy, Clone, Debug)]
+pub enum DkimCanonicalizationType {
+    Simple,
+    Relaxed,
+}
+
+impl Display for DkimCanonicalizationType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            DkimCanonicalizationType::Simple => "simple",
+            DkimCanonicalizationType::Relaxed => "relaxed",
+        })
+    }
+}
+
+/// Describe Canonicalization to be applied before signing
+#[derive(Copy, Clone, Debug)]
+pub struct DkimCanonicalization {
+    pub header: DkimCanonicalizationType,
+    pub body: DkimCanonicalizationType,
+}
+
+impl Default for DkimCanonicalization {
+    fn default() -> Self {
+        DkimCanonicalization {
+            header: DkimCanonicalizationType::Simple,
+            body: DkimCanonicalizationType::Relaxed,
+        }
+    }
+}
+
+/// Format canonicalization to be shown in Dkim header
+impl Display for DkimCanonicalization {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}/{}", self.header, self.body)
+    }
+}
+
+/// Describe the algorithm used for signing the message
+#[derive(Copy, Clone, Debug)]
+pub enum DkimSigningAlgorithm {
+    Rsa,
+    Ed25519,
+}
+
+impl Display for DkimSigningAlgorithm {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            DkimSigningAlgorithm::Rsa => "rsa",
+            DkimSigningAlgorithm::Ed25519 => "ed25519",
+        })
+    }
+}
+
+/// Describe DkimSigning key error
+#[derive(Debug)]
+pub struct DkimSigningKeyError(InnerDkimSigningKeyError);
+
+#[derive(Debug)]
+enum InnerDkimSigningKeyError {
+    Base64(base64::DecodeError),
+    Rsa(rsa::pkcs1::Error),
+    Ed25519(ed25519_dalek::ed25519::Error),
+}
+
+impl Display for DkimSigningKeyError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match &self.0 {
+            InnerDkimSigningKeyError::Base64(_err) => "base64 decode error",
+            InnerDkimSigningKeyError::Rsa(_err) => "rsa decode error",
+            InnerDkimSigningKeyError::Ed25519(_err) => "ed25519 decode error",
+        })
+    }
+}
+
+impl StdError for DkimSigningKeyError {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        Some(match &self.0 {
+            InnerDkimSigningKeyError::Base64(err) => err,
+            InnerDkimSigningKeyError::Rsa(err) => err,
+            InnerDkimSigningKeyError::Ed25519(err) => err,
+        })
+    }
+}
+
+/// Describe a signing key to be carried by DkimConfig struct
+#[derive(Debug)]
+pub struct DkimSigningKey(InnerDkimSigningKey);
+
+#[derive(Debug)]
+enum InnerDkimSigningKey {
+    Rsa(RsaPrivateKey),
+    Ed25519(ed25519_dalek::SigningKey),
+}
+
+impl DkimSigningKey {
+    pub fn new(
+        private_key: &str,
+        algorithm: DkimSigningAlgorithm,
+    ) -> Result<DkimSigningKey, DkimSigningKeyError> {
+        Ok(Self(match algorithm {
+            DkimSigningAlgorithm::Rsa => InnerDkimSigningKey::Rsa(
+                RsaPrivateKey::from_pkcs1_pem(private_key)
+                    .map_err(|err| DkimSigningKeyError(InnerDkimSigningKeyError::Rsa(err)))?,
+            ),
+            DkimSigningAlgorithm::Ed25519 => {
+                InnerDkimSigningKey::Ed25519(ed25519_dalek::SigningKey::from_bytes(
+                    &crate::base64::decode(private_key)
+                        .map_err(|err| DkimSigningKeyError(InnerDkimSigningKeyError::Base64(err)))?
+                        .try_into()
+                        .map_err(|_| {
+                            DkimSigningKeyError(InnerDkimSigningKeyError::Ed25519(
+                                ed25519_dalek::ed25519::Error::new(),
+                            ))
+                        })?,
+                ))
+            }
+        }))
+    }
+    fn get_signing_algorithm(&self) -> DkimSigningAlgorithm {
+        match self.0 {
+            InnerDkimSigningKey::Rsa(_) => DkimSigningAlgorithm::Rsa,
+            InnerDkimSigningKey::Ed25519(_) => DkimSigningAlgorithm::Ed25519,
+        }
+    }
+}
+
+/// A struct to describe Dkim configuration applied when signing a message
+#[derive(Debug)]
+pub struct DkimConfig {
+    /// The name of the key published in DNS
+    selector: String,
+    /// The domain for which we sign the message
+    domain: String,
+    /// The private key in PKCS1 string format
+    private_key: DkimSigningKey,
+    /// A list of header names to be included in the signature. Signing of more than one
+    /// header with the same name is not supported
+    headers: Vec<HeaderName>,
+    /// The signing algorithm to be used when signing
+    canonicalization: DkimCanonicalization,
+}
+
+impl DkimConfig {
+    /// Create a default signature configuration with a set of headers and "simple/relaxed"
+    /// canonicalization
+    pub fn default_config(
+        selector: String,
+        domain: String,
+        private_key: DkimSigningKey,
+    ) -> DkimConfig {
+        DkimConfig {
+            selector,
+            domain,
+            private_key,
+            headers: vec![
+                HeaderName::new_from_ascii_str("From"),
+                HeaderName::new_from_ascii_str("Subject"),
+                HeaderName::new_from_ascii_str("To"),
+                HeaderName::new_from_ascii_str("Date"),
+            ],
+            canonicalization: DkimCanonicalization {
+                header: DkimCanonicalizationType::Simple,
+                body: DkimCanonicalizationType::Relaxed,
+            },
+        }
+    }
+
+    /// Create a DkimConfig
+    pub fn new(
+        selector: String,
+        domain: String,
+        private_key: DkimSigningKey,
+        headers: Vec<HeaderName>,
+        canonicalization: DkimCanonicalization,
+    ) -> DkimConfig {
+        DkimConfig {
+            selector,
+            domain,
+            private_key,
+            headers,
+            canonicalization,
+        }
+    }
+}
+
+/// Create a Headers struct with a Dkim-Signature Header created from given parameters
+fn dkim_header_format(
+    config: &DkimConfig,
+    timestamp: u64,
+    headers_list: &str,
+    body_hash: &str,
+    signature: &str,
+) -> Headers {
+    let mut headers = Headers::new();
+    let header_name =
+        dkim_canonicalize_header_tag("DKIM-Signature", config.canonicalization.header);
+    let header_name = HeaderName::new_from_ascii(header_name.into()).unwrap();
+    headers.insert_raw(HeaderValue::new(header_name, format!("v=1; a={signing_algorithm}-sha256; d={domain}; s={selector}; c={canon}; q=dns/txt; t={timestamp}; h={headers_list}; bh={body_hash}; b={signature}",domain=config.domain, selector=config.selector,canon=config.canonicalization,timestamp=timestamp,headers_list=headers_list,body_hash=body_hash,signature=signature,signing_algorithm=config.private_key.get_signing_algorithm())));
+    headers
+}
+
+/// Canonicalize the body of an email
+fn dkim_canonicalize_body(
+    mut body: &[u8],
+    canonicalization: DkimCanonicalizationType,
+) -> Cow<'_, [u8]> {
+    match canonicalization {
+        DkimCanonicalizationType::Simple => {
+            // Remove empty lines at end
+            while body.ends_with(b"\r\n\r\n") {
+                body = &body[..body.len() - 2];
+            }
+            Cow::Borrowed(body)
+        }
+        DkimCanonicalizationType::Relaxed => {
+            let mut out = Vec::with_capacity(body.len());
+            loop {
+                match body {
+                    [b' ' | b'\t', b'\r', b'\n', ..] => {}
+                    [b' ' | b'\t', b' ' | b'\t', ..] => {}
+                    [b' ' | b'\t', ..] => out.push(b' '),
+                    [c, ..] => out.push(*c),
+                    [] => break,
+                }
+                body = &body[1..];
+            }
+            // Remove empty lines at end
+            while out.ends_with(b"\r\n\r\n") {
+                out.truncate(out.len() - 2);
+            }
+            Cow::Owned(out)
+        }
+    }
+}
+
+fn dkim_canonicalize_headers_relaxed(headers: &str) -> String {
+    let mut r = String::with_capacity(headers.len());
+
+    fn skip_whitespace(h: &str) -> &str {
+        match h.as_bytes().first() {
+            Some(b' ' | b'\t') => skip_whitespace(&h[1..]),
+            _ => h,
+        }
+    }
+
+    fn name(h: &str, out: &mut String) {
+        if let Some(name_end) = h.bytes().position(|c| c == b':') {
+            let (name, rest) = h.split_at(name_end + 1);
+            *out += name;
+            // Space after header colon is stripped.
+            value(skip_whitespace(rest), out);
+        } else {
+            // This should never happen.
+            *out += h;
+        }
+    }
+
+    fn value(h: &str, out: &mut String) {
+        match h.as_bytes() {
+            // Continuation lines.
+            [b'\r', b'\n', b' ' | b'\t', ..] => {
+                out.push(' ');
+                value(skip_whitespace(&h[2..]), out);
+            }
+            // End of header.
+            [b'\r', b'\n', ..] => {
+                *out += "\r\n";
+                name(&h[2..], out)
+            }
+            // Sequential whitespace.
+            [b' ' | b'\t', b' ' | b'\t' | b'\r', ..] => value(&h[1..], out),
+            // All whitespace becomes spaces.
+            [b'\t', ..] => {
+                out.push(' ');
+                value(&h[1..], out)
+            }
+            [_, ..] => {
+                let mut chars = h.chars();
+                out.push(chars.next().unwrap());
+                value(chars.as_str(), out)
+            }
+            [] => {}
+        }
+    }
+
+    name(headers, &mut r);
+
+    r
+}
+
+/// Canonicalize header tag
+fn dkim_canonicalize_header_tag(
+    name: &str,
+    canonicalization: DkimCanonicalizationType,
+) -> Cow<'_, str> {
+    match canonicalization {
+        DkimCanonicalizationType::Simple => Cow::Borrowed(name),
+        DkimCanonicalizationType::Relaxed => Cow::Owned(name.to_lowercase()),
+    }
+}
+
+/// Canonicalize signed headers passed as headers_list among mail_headers using canonicalization
+fn dkim_canonicalize_headers<'a>(
+    headers_list: impl IntoIterator<Item = &'a str>,
+    mail_headers: &Headers,
+    canonicalization: DkimCanonicalizationType,
+) -> String {
+    let mut covered_headers = Headers::new();
+    for name in headers_list {
+        if let Some(h) = mail_headers.find_header(name) {
+            let name = dkim_canonicalize_header_tag(name, canonicalization);
+            covered_headers.insert_raw(HeaderValue::dangerous_new_pre_encoded(
+                HeaderName::new_from_ascii(name.into()).unwrap(),
+                h.get_raw().into(),
+                h.get_encoded().into(),
+            ));
+        }
+    }
+
+    let serialized = covered_headers.to_string();
+
+    match canonicalization {
+        DkimCanonicalizationType::Simple => serialized,
+        DkimCanonicalizationType::Relaxed => dkim_canonicalize_headers_relaxed(&serialized),
+    }
+}
+
+/// Sign with Dkim a message by adding Dkim-Signature header created with configuration expressed by
+/// dkim_config
+
+pub fn dkim_sign(message: &mut Message, dkim_config: &DkimConfig) {
+    dkim_sign_fixed_time(message, dkim_config, SystemTime::now())
+}
+
+fn dkim_sign_fixed_time(message: &mut Message, dkim_config: &DkimConfig, timestamp: SystemTime) {
+    let timestamp = timestamp
+        .duration_since(SystemTime::UNIX_EPOCH)
+        .unwrap()
+        .as_secs();
+    let headers = message.headers();
+    let body_hash = Sha256::digest(dkim_canonicalize_body(
+        &message.body_raw(),
+        dkim_config.canonicalization.body,
+    ));
+    let bh = crate::base64::encode(body_hash);
+    let mut signed_headers_list =
+        dkim_config
+            .headers
+            .iter()
+            .fold(String::new(), |mut list, header| {
+                if !list.is_empty() {
+                    list.push(':');
+                }
+
+                list.push_str(header);
+                list
+            });
+    if let DkimCanonicalizationType::Relaxed = dkim_config.canonicalization.header {
+        signed_headers_list.make_ascii_lowercase();
+    }
+    let dkim_header = dkim_header_format(dkim_config, timestamp, &signed_headers_list, &bh, "");
+    let signed_headers = dkim_canonicalize_headers(
+        dkim_config.headers.iter().map(|h| h.as_ref()),
+        headers,
+        dkim_config.canonicalization.header,
+    );
+    let canonicalized_dkim_header = dkim_canonicalize_headers(
+        ["DKIM-Signature"],
+        &dkim_header,
+        dkim_config.canonicalization.header,
+    );
+    let mut hashed_headers = Sha256::new();
+    hashed_headers.update(signed_headers.as_bytes());
+    hashed_headers.update(canonicalized_dkim_header.trim_end().as_bytes());
+    let hashed_headers = hashed_headers.finalize();
+    let signature = match &dkim_config.private_key.0 {
+        InnerDkimSigningKey::Rsa(private_key) => crate::base64::encode(
+            private_key
+                .sign(Pkcs1v15Sign::new::<Sha256>(), &hashed_headers)
+                .unwrap(),
+        ),
+        InnerDkimSigningKey::Ed25519(private_key) => {
+            crate::base64::encode(private_key.sign(&hashed_headers).to_bytes())
+        }
+    };
+    let dkim_header = dkim_header_format(
+        dkim_config,
+        timestamp,
+        &signed_headers_list,
+        &bh,
+        &signature,
+    );
+    message.headers.insert_raw(HeaderValue::new(
+        HeaderName::new_from_ascii_str("DKIM-Signature"),
+        dkim_header.get_raw("DKIM-Signature").unwrap().to_owned(),
+    ));
+}
+
+#[cfg(test)]
+mod test {
+    use pretty_assertions::assert_eq;
+
+    use super::{
+        super::{
+            header::{HeaderName, HeaderValue},
+            Header, Message,
+        },
+        dkim_canonicalize_body, dkim_canonicalize_headers, dkim_sign_fixed_time,
+        DkimCanonicalization, DkimCanonicalizationType, DkimConfig, DkimSigningAlgorithm,
+        DkimSigningKey,
+    };
+    use crate::StdError;
+
+    const KEY_RSA: &str = "-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEAwOsW7UFcWn1ch3UM8Mll5qZH5hVHKJQ8Z0tUlebUECq0vjw6
+VcsIucZ/B70VpCN63whyi7oApdCIS1o0zad7f0UaW/BfxXADqdcFL36uMaG0RHer
+uSASjQGnsl9Kozt/dXiDZX5ngjr/arLJhNZSNR4/9VSwqbE2OPXaSaQ9BsqneD0P
+8dCVSfkkDZCcfC2864z7hvC01lFzWQKF36ZAoGBERHScHtFMAzUOgGuqqPiP5khw
+DQB3Ffccf+BsWLU2OOteshUwTGjpoangbPCYj6kckwNm440lQwuqTinpC92yyIE5
+Ol8psNMW49DLowAeZb6JrjLhD+wY9bghTaOkcwIDAQABAoIBAHTZ8LkkrdvhsvoZ
+XA088AwVC9fBa6iYoT2v0zw45JomQ/Q2Zt8wa8ibAradQU56byJI65jWwS2ucd+y
+c+ldWOBt6tllb50XjCCDrRBnmvtVBuux0MIBOztNlVXlgj/8+ecdZ/lB51Bqi+sF
+ACsF5iVmfTcMZTVjsYQu5llUseI6Lwgqpx6ktaXD2PVsVo9Gf01ssZ4GCy69wB/3
+20CsOz4LEpSYkq1oE98lMMGCfD7py3L9kWHYNNisam78GM+1ynRxRGwEDUbz6pxs
+fGPIAwHLaZsOmibPkBB0PJTW742w86qQ8KAqC6ZbRYOF19rSMj3oTfRnPMHn9Uu5
+N8eQcoECgYEA97SMUrz2hqII5i8igKylO9kV8pjcIWKI0rdt8MKj4FXTNYjjO9I+
+41ONOjhUOpFci/G3YRKi8UiwbKxIRTvIxNMh2xj6Ws3iO9gQHK1j8xTWxJdjEBEz
+EuZI59Mi5H7fxSL1W+n8nS8JVsaH93rvQErngqTUAsihAzjxHWdFwm0CgYEAx2Dh
+claESJP2cOKgYp+SUNwc26qMaqnl1f37Yn+AflrQOfgQqJe5TRbicEC+nFlm6XUt
+3st1Nj29H0uOMmMZDmDCO+cOs5Qv5A9pG6jSC6wM+2KNHQDtrxlakBFygePEPVVy
+GXaY9DRa9Q4/4ataxDR2/VvIAWfEEtMTJIBDtl8CgYAIXEuwLziS6r0qJ8UeWrVp
+A7a97XLgnZbIpfBMBAXL+JmcYPZqenos6hEGOgh9wZJCFvJ9kEd3pWBvCpGV5KKu
+IgIuhvVMQ06zfmNs1F1fQwDMud9aF3qF1Mf5KyMuWynqWXe2lns0QvYpu6GzNK8G
+mICf5DhTr7nfhfh9aZLtMQKBgCxKsmqzG5n//MxhHB4sstVxwJtwDNeZPKzISnM8
+PfBT/lQSbqj1Y73japRjXbTgC4Ore3A2JKjTGFN+dm1tJGDUT/H8x4BPWEBCyCfT
+3i2noA6sewrJbQPsDvlYVubSEYNKmxlbBmmhw98StlBMv9I8kX6BSDI/uggwid0e
+/WvjAoGBAKpZ0UOKQyrl9reBiUfrpRCvIMakBMd79kNiH+5y0Soq/wCAnAuABayj
+XEIBhFv+HxeLEnT7YV+Zzqp5L9kKw/EU4ik3JX/XsEihdSxEuGX00ZYOw05FEfpW
+cJ5Ku0OTwRtSMaseRPX+T4EfG1Caa/eunPPN4rh+CSup2BVVarOT
+-----END RSA PRIVATE KEY-----";
+
+    #[derive(Clone)]
+    struct TestHeader(String);
+
+    impl Header for TestHeader {
+        fn name() -> HeaderName {
+            HeaderName::new_from_ascii_str("Test")
+        }
+
+        fn parse(s: &str) -> Result<Self, Box<dyn StdError + Send + Sync>> {
+            Ok(Self(s.into()))
+        }
+
+        fn display(&self) -> HeaderValue {
+            HeaderValue::new(Self::name(), self.0.clone())
+        }
+    }
+
+    fn test_message() -> Message {
+        Message::builder()
+            .from("Test O'Leary <test+ezrz@example.net>".parse().unwrap())
+            .to("Test2 <test2@example.org>".parse().unwrap())
+            .date(std::time::UNIX_EPOCH)
+            .header(TestHeader("test  test very very long with spaces and extra spaces   \twill be folded to several lines ".to_owned()))
+            .subject("Test with utf-8 ë")
+            .body("test\r\n\r\ntest   \ttest\r\n\r\n\r\n".to_owned()).unwrap()
+    }
+
+    #[test]
+    fn test_headers_simple_canonicalize() {
+        let message = test_message();
+        dbg!(message.headers.to_string());
+        assert_eq!(dkim_canonicalize_headers(["From", "Test"], &message.headers, DkimCanonicalizationType::Simple), "From: =?utf-8?b?VGVzdCBPJ0xlYXJ5?= <test+ezrz@example.net>\r\nTest: test  test very very long with spaces and extra spaces   \twill be\r\n folded to several lines \r\n")
+    }
+
+    #[test]
+    fn test_headers_relaxed_canonicalize() {
+        let message = test_message();
+        dbg!(message.headers.to_string());
+        assert_eq!(dkim_canonicalize_headers(["From", "Test"], &message.headers, DkimCanonicalizationType::Relaxed),"from:=?utf-8?b?VGVzdCBPJ0xlYXJ5?= <test+ezrz@example.net>\r\ntest:test test very very long with spaces and extra spaces will be folded to several lines\r\n")
+    }
+
+    #[test]
+    fn test_body_simple_canonicalize() {
+        let body = b" C \r\nD \t E\r\n\r\n\r\n";
+        assert_eq!(
+            dkim_canonicalize_body(body, DkimCanonicalizationType::Simple).into_owned(),
+            b" C \r\nD \t E\r\n"
+        );
+    }
+
+    #[test]
+    fn test_body_relaxed_canonicalize() {
+        let body = b" C \r\nD \t E\r\n\tF\r\n\t\r\n\r\n\r\n";
+        assert_eq!(
+            dkim_canonicalize_body(body, DkimCanonicalizationType::Relaxed).into_owned(),
+            b" C\r\nD E\r\n F\r\n"
+        );
+    }
+
+    #[test]
+    fn test_signature_rsa_simple() {
+        let mut message = test_message();
+        let signing_key = DkimSigningKey::new(KEY_RSA, DkimSigningAlgorithm::Rsa).unwrap();
+        dkim_sign_fixed_time(
+            &mut message,
+            &DkimConfig::new(
+                "dkimtest".to_owned(),
+                "example.org".to_owned(),
+                signing_key,
+                vec![
+                    HeaderName::new_from_ascii_str("Date"),
+                    HeaderName::new_from_ascii_str("From"),
+                    HeaderName::new_from_ascii_str("Subject"),
+                    HeaderName::new_from_ascii_str("To"),
+                ],
+                DkimCanonicalization {
+                    header: DkimCanonicalizationType::Simple,
+                    body: DkimCanonicalizationType::Simple,
+                },
+            ),
+            std::time::UNIX_EPOCH,
+        );
+        let signed = message.formatted();
+        let signed = std::str::from_utf8(&signed).unwrap();
+        assert_eq!(
+            signed,
+            std::concat!(
+                "From: =?utf-8?b?VGVzdCBPJ0xlYXJ5?= <test+ezrz@example.net>\r\n",
+                "To: Test2 <test2@example.org>\r\n",
+                "Date: Thu, 01 Jan 1970 00:00:00 +0000\r\n",
+                "Test: test  test very very long with spaces and extra spaces   \twill be\r\n",
+                " folded to several lines \r\n",
+                "Subject: Test with utf-8 =?utf-8?b?w6s=?=\r\n",
+                "Content-Transfer-Encoding: 7bit\r\n",
+                "DKIM-Signature: v=1; a=rsa-sha256; d=example.org; s=dkimtest;\r\n",
+                " c=simple/simple; q=dns/txt; t=0; h=Date:From:Subject:To;\r\n",
+                " bh=f3Zksdcjqa/xRBwdyFzIXWCcgP7XTgxjCgYsXOMKQl4=;\r\n",
+                " b=NhoIMMAALoSgu5lKAR0+MUQunOWnU7wpF9ORUFtpxq9sGZDo9AX43AMhFemyM5W204jpFwMU6pm7AMR1nOYBdSYye4yUALtvT2nqbJBwSh7JeYu+z22t1RFKp7qQR1il8aSrkbZuNMFHYuSEwW76QtKwcNqP4bQOzS9CzgQp0ABu8qwYPBr/EypykPTfqjtyN+ywrfdqjjGOzTpRGolH0hc3CrAETNjjHbNBgKgucXmXTN7hMRdzqWjeFPxizXwouwNAavFClPG0l33gXVArFWn+CkgA84G/s4zuJiF7QPZR87Pu4pw/vIlSXxH4a42W3tT19v9iBTH7X7ldYegtmQ==\r\n",
+                "\r\n",
+                "test\r\n",
+                "\r\n",
+                "test   \ttest\r\n",
+                "\r\n",
+                "\r\n",
+            )
+        );
+    }
+
+    #[test]
+    fn test_signature_rsa_relaxed() {
+        let mut message = test_message();
+        let signing_key = DkimSigningKey::new(KEY_RSA, DkimSigningAlgorithm::Rsa).unwrap();
+        dkim_sign_fixed_time(
+            &mut message,
+            &DkimConfig::new(
+                "dkimtest".to_owned(),
+                "example.org".to_owned(),
+                signing_key,
+                vec![
+                    HeaderName::new_from_ascii_str("Date"),
+                    HeaderName::new_from_ascii_str("From"),
+                    HeaderName::new_from_ascii_str("Subject"),
+                    HeaderName::new_from_ascii_str("To"),
+                ],
+                DkimCanonicalization {
+                    header: DkimCanonicalizationType::Relaxed,
+                    body: DkimCanonicalizationType::Relaxed,
+                },
+            ),
+            std::time::UNIX_EPOCH,
+        );
+        let signed = message.formatted();
+        let signed = std::str::from_utf8(&signed).unwrap();
+        println!("{signed}");
+        assert_eq!(
+            signed,
+            std::concat!(
+                "From: =?utf-8?b?VGVzdCBPJ0xlYXJ5?= <test+ezrz@example.net>\r\n",
+                "To: Test2 <test2@example.org>\r\n",
+                "Date: Thu, 01 Jan 1970 00:00:00 +0000\r\n",
+                "Test: test  test very very long with spaces and extra spaces   \twill be\r\n",
+                " folded to several lines \r\n","Subject: Test with utf-8 =?utf-8?b?w6s=?=\r\n",
+                "Content-Transfer-Encoding: 7bit\r\n",
+                "DKIM-Signature: v=1; a=rsa-sha256; d=example.org; s=dkimtest;\r\n",
+                " c=relaxed/relaxed; q=dns/txt; t=0; h=date:from:subject:to;\r\n",
+                " bh=qN8je6qJgWFGSnN2MycC/XKPbN6BOrMJyAX2h4m19Ss=;\r\n",
+                " b=YaVfmH8dbGEywoLJ4uhbvYqDyQG1UGKFH3PE7zXGgk+YFxUgkwWjoA3aQupDNQtfTjfUsNe0dnrjyZP+ylnESpZBpbCIf5/n3FEh6j3RQthqNbQblcfH/U8mazTuRbVjYBbTZQDaQCMPTz+8D+ZQfXo2oq6dGzTuGvmuYft0CVsq/BIp/EkhZHqiphDeVJSHD4iKW8+L2XwEWThoY92xOYc1G0TtBwz2UJgtiHX2YulH/kRBHeK3dKn9RTNVL3VZ+9ZrnFwIhET9TPGtU2I+q0EMSWF9H9bTrASMgW/U+E0VM2btqJlrTU6rQ7wlQeHdwecLnzXcyhCUInF1+veMNw==\r\n",
+                "\r\n",
+                "test\r\n",
+                "\r\n",
+                "test   \ttest\r\n",
+                "\r\n",
+                "\r\n",
+            )
+        );
+    }
+}

src/message/header/content.rs

@@ -3,7 +3,7 @@ use std::{
     str::FromStr,
 };
 
-use super::{Header, HeaderName};
+use super::{Header, HeaderName, HeaderValue};
 use crate::BoxError;
 
 /// `Content-Transfer-Encoding` of the body
@@ -11,13 +11,16 @@ use crate::BoxError;
 /// 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)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Default)]
 pub enum ContentTransferEncoding {
     /// ASCII
     SevenBit,
     /// Quoted-Printable encoding
     QuotedPrintable,
     /// base64 encoding
+    #[default]
     Base64,
     /// Requires `8BITMIME`
     EightBit,
@@ -34,8 +37,9 @@ impl Header for ContentTransferEncoding {
         Ok(s.parse()?)
     }
 
-    fn display(&self) -> String {
-        self.to_string()
+    fn display(&self) -> HeaderValue {
+        let val = self.to_string();
+        HeaderValue::dangerous_new_pre_encoded(Self::name(), val.clone(), val)
     }
 }
 
@@ -65,16 +69,12 @@ impl FromStr for ContentTransferEncoding {
     }
 }
 
-impl Default for ContentTransferEncoding {
-    fn default() -> Self {
-        ContentTransferEncoding::Base64
-    }
-}
-
 #[cfg(test)]
 mod test {
+    use pretty_assertions::assert_eq;
+
     use super::ContentTransferEncoding;
-    use crate::message::header::{HeaderName, Headers};
+    use crate::message::header::{HeaderName, HeaderValue, Headers};
 
     #[test]
     fn format_content_transfer_encoding() {
@@ -93,20 +93,20 @@ mod test {
     fn parse_content_transfer_encoding() {
         let mut headers = Headers::new();
 
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("Content-Transfer-Encoding"),
-            "7bit".to_string(),
-        );
+            "7bit".to_owned(),
+        ));
 
         assert_eq!(
             headers.get::<ContentTransferEncoding>(),
             Some(ContentTransferEncoding::SevenBit)
         );
 
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("Content-Transfer-Encoding"),
-            "base64".to_string(),
-        );
+            "base64".to_owned(),
+        ));
 
         assert_eq!(
             headers.get::<ContentTransferEncoding>(),

src/message/header/content_disposition.rs

@@ -1,29 +1,57 @@
-use super::{Header, HeaderName};
+use std::fmt::Write;
+
+use email_encoding::headers::writer::EmailWriter;
+
+use super::{Header, HeaderName, HeaderValue};
 use crate::BoxError;
 
 /// `Content-Disposition` of an attachment
 ///
 /// Defined in [RFC2183](https://tools.ietf.org/html/rfc2183)
 #[derive(Debug, Clone, PartialEq)]
-pub struct ContentDisposition(String);
+pub struct ContentDisposition(HeaderValue);
 
 impl ContentDisposition {
     /// An attachment which should be displayed inline into the message
     pub fn inline() -> Self {
-        Self("inline".into())
+        Self(HeaderValue::dangerous_new_pre_encoded(
+            Self::name(),
+            "inline".to_owned(),
+            "inline".to_owned(),
+        ))
     }
 
     /// An attachment which should be displayed inline into the message, but that also
-    /// species the filename in case it were to be downloaded
+    /// species the filename in case it is downloaded
     pub fn inline_with_name(file_name: &str) -> Self {
-        debug_assert!(!file_name.contains('"'), "file_name shouldn't contain '\"'");
-        Self(format!("inline; filename=\"{}\"", file_name))
+        Self::with_name("inline", file_name)
     }
 
     /// An attachment which is separate from the body of the message, and can be downloaded separately
     pub fn attachment(file_name: &str) -> Self {
-        debug_assert!(!file_name.contains('"'), "file_name shouldn't contain '\"'");
-        Self(format!("attachment; filename=\"{}\"", file_name))
+        Self::with_name("attachment", file_name)
+    }
+
+    fn with_name(kind: &str, file_name: &str) -> Self {
+        let raw_value = format!("{kind}; filename=\"{file_name}\"");
+
+        let mut encoded_value = String::new();
+        let line_len = "Content-Disposition: ".len();
+        {
+            let mut w = EmailWriter::new(&mut encoded_value, line_len, 0, false);
+            w.write_str(kind).expect("writing `kind` returned an error");
+            w.write_char(';').expect("writing `;` returned an error");
+            w.space();
+
+            email_encoding::headers::rfc2231::encode("filename", file_name, &mut w)
+                .expect("some Write implementation returned an error");
+        }
+
+        Self(HeaderValue::dangerous_new_pre_encoded(
+            Self::name(),
+            raw_value,
+            encoded_value,
+        ))
     }
 }
 
@@ -33,18 +61,28 @@ impl Header for ContentDisposition {
     }
 
     fn parse(s: &str) -> Result<Self, BoxError> {
-        Ok(Self(s.into()))
+        match (s.split_once(';'), s) {
+            (_, "inline") => Ok(Self::inline()),
+            (Some((kind @ ("inline" | "attachment"), file_name)), _) => file_name
+                .split_once(" filename=\"")
+                .and_then(|(_, file_name)| file_name.strip_suffix('"'))
+                .map(|file_name| Self::with_name(kind, file_name))
+                .ok_or_else(|| "Unsupported ContentDisposition value".into()),
+            _ => Err("Unsupported ContentDisposition value".into()),
+        }
     }
 
-    fn display(&self) -> String {
+    fn display(&self) -> HeaderValue {
         self.0.clone()
     }
 }
 
 #[cfg(test)]
 mod test {
+    use pretty_assertions::assert_eq;
+
     use super::ContentDisposition;
-    use crate::message::header::{HeaderName, Headers};
+    use crate::message::header::{HeaderName, HeaderValue, Headers};
 
     #[test]
     fn format_content_disposition() {
@@ -52,12 +90,12 @@ mod test {
 
         headers.set(ContentDisposition::inline());
 
-        assert_eq!(format!("{}", headers), "Content-Disposition: inline\r\n");
+        assert_eq!(format!("{headers}"), "Content-Disposition: inline\r\n");
 
         headers.set(ContentDisposition::attachment("something.txt"));
 
         assert_eq!(
-            format!("{}", headers),
+            format!("{headers}"),
             "Content-Disposition: attachment; filename=\"something.txt\"\r\n"
         );
     }
@@ -66,20 +104,20 @@ mod test {
     fn parse_content_disposition() {
         let mut headers = Headers::new();
 
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("Content-Disposition"),
-            "inline".to_string(),
-        );
+            "inline".to_owned(),
+        ));
 
         assert_eq!(
             headers.get::<ContentDisposition>(),
             Some(ContentDisposition::inline())
         );
 
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("Content-Disposition"),
-            "attachment; filename=\"something.txt\"".to_string(),
-        );
+            "attachment; filename=\"something.txt\"".to_owned(),
+        ));
 
         assert_eq!(
             headers.get::<ContentDisposition>(),

src/message/header/content_type.rs

@@ -6,13 +6,18 @@ use std::{
 
 use mime::Mime;
 
-use super::{Header, HeaderName};
+use super::{Header, HeaderName, HeaderValue};
 use crate::BoxError;
 
 /// `Content-Type` of the body
 ///
+/// This struct can represent any valid [MIME type], which can be parsed via
+/// [`ContentType::parse`]. Constants are provided for the most-used mime-types.
+///
 /// Defined in [RFC2045](https://tools.ietf.org/html/rfc2045#section-5)
-#[derive(Debug, Clone, PartialEq)]
+///
+/// [MIME type]: https://www.iana.org/assignments/media-types/media-types.xhtml
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ContentType(Mime);
 
 impl ContentType {
@@ -49,8 +54,8 @@ impl Header for ContentType {
         Ok(Self(s.parse()?))
     }
 
-    fn display(&self) -> String {
-        self.0.to_string()
+    fn display(&self) -> HeaderValue {
+        HeaderValue::new(Self::name(), self.0.to_string())
     }
 }
 
@@ -62,6 +67,14 @@ impl FromStr for ContentType {
     }
 }
 
+#[cfg(feature = "mime03")]
+#[cfg_attr(docsrs, doc(cfg(feature = "mime03")))]
+impl From<Mime> for ContentType {
+    fn from(mime: Mime) -> Self {
+        Self::from_mime(mime)
+    }
+}
+
 /// An error occurred while trying to [`ContentType::parse`].
 #[derive(Debug)]
 pub struct ContentTypeErr(mime::FromStrError);
@@ -78,10 +91,67 @@ impl Display for ContentTypeErr {
     }
 }
 
+// -- Serialization and Deserialization --
+#[cfg(feature = "serde")]
+mod serde {
+    use std::fmt;
+
+    use serde::{
+        de::{self, Deserialize, Deserializer, Visitor},
+        ser::{Serialize, Serializer},
+    };
+
+    use super::ContentType;
+
+    impl Serialize for ContentType {
+        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: Serializer,
+        {
+            serializer.serialize_newtype_struct("ContentType", &format!("{}", &self.0))
+        }
+    }
+
+    impl<'de> Deserialize<'de> for ContentType {
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            struct ContentTypeVisitor;
+
+            impl<'de> Visitor<'de> for ContentTypeVisitor {
+                type Value = ContentType;
+
+                // The error message which states what the Visitor expects to
+                // receive
+                fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                    formatter.write_str("a ContentType string like `text/plain`")
+                }
+
+                fn visit_str<E>(self, mime: &str) -> Result<ContentType, E>
+                where
+                    E: de::Error,
+                {
+                    match ContentType::parse(mime) {
+                        Ok(content_type) => Ok(content_type),
+                        Err(_) => Err(E::custom(format!(
+                            "Couldn't parse the following MIME-Type: {mime}"
+                        ))),
+                    }
+                }
+            }
+
+            deserializer.deserialize_str(ContentTypeVisitor)
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
+    use pretty_assertions::assert_eq;
+
     use super::ContentType;
-    use crate::message::header::{HeaderName, Headers};
+    use crate::message::header::{HeaderName, HeaderValue, Headers};
 
     #[test]
     fn format_content_type() {
@@ -106,17 +176,17 @@ mod test {
     fn parse_content_type() {
         let mut headers = Headers::new();
 
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("Content-Type"),
-            "text/plain; charset=utf-8".to_string(),
-        );
+            "text/plain; charset=utf-8".to_owned(),
+        ));
 
         assert_eq!(headers.get::<ContentType>(), Some(ContentType::TEXT_PLAIN));
 
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("Content-Type"),
-            "text/html; charset=utf-8".to_string(),
-        );
+            "text/html; charset=utf-8".to_owned(),
+        ));
 
         assert_eq!(headers.get::<ContentType>(), Some(ContentType::TEXT_HTML));
     }

src/message/header/date.rs

@@ -2,13 +2,13 @@ use std::time::SystemTime;
 
 use httpdate::HttpDate;
 
-use super::{Header, HeaderName};
+use super::{Header, HeaderName, HeaderValue};
 use crate::BoxError;
 
 /// Message `Date` header
 ///
 /// Defined in [RFC2822](https://tools.ietf.org/html/rfc2822#section-3.3)
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct Date(HttpDate);
 
 impl Date {
@@ -32,29 +32,29 @@ impl Header for Date {
 
     fn parse(s: &str) -> Result<Self, BoxError> {
         let mut s = String::from(s);
-        if s.ends_with(" -0000") {
+        if s.ends_with("+0000") {
             // The httpdate crate expects the `Date` to end in ` GMT`, but email
-            // uses `-0000`, so we crudely fix this issue here.
+            // uses `+0000` to indicate UTC, so we crudely fix this issue here.
 
-            s.truncate(s.len() - "-0000".len());
+            s.truncate(s.len() - "+0000".len());
             s.push_str("GMT");
         }
 
         Ok(Self(s.parse::<HttpDate>()?))
     }
 
-    fn display(&self) -> String {
-        let mut s = self.0.to_string();
-        if s.ends_with(" GMT") {
+    fn display(&self) -> HeaderValue {
+        let mut val = self.0.to_string();
+        if val.ends_with(" GMT") {
             // The httpdate crate always appends ` GMT` to the end of the string,
             // but this is considered an obsolete date format for email
             // https://tools.ietf.org/html/rfc2822#appendix-A.6.2,
-            // so we replace `GMT` with `-0000`
-            s.truncate(s.len() - "GMT".len());
-            s.push_str("-0000");
+            // so we replace `GMT` with `+0000`
+            val.truncate(val.len() - "GMT".len());
+            val.push_str("+0000");
         }
 
-        s
+        HeaderValue::dangerous_new_pre_encoded(Self::name(), val.clone(), val)
     }
 }
 
@@ -74,8 +74,10 @@ impl From<Date> for SystemTime {
 mod test {
     use std::time::{Duration, SystemTime};
 
+    use pretty_assertions::assert_eq;
+
     use super::Date;
-    use crate::message::header::{HeaderName, Headers};
+    use crate::message::header::{HeaderName, HeaderValue, Headers};
 
     #[test]
     fn format_date() {
@@ -88,7 +90,7 @@ mod test {
 
         assert_eq!(
             headers.to_string(),
-            "Date: Tue, 15 Nov 1994 08:12:31 -0000\r\n".to_string()
+            "Date: Tue, 15 Nov 1994 08:12:31 +0000\r\n".to_owned()
         );
 
         // Tue, 15 Nov 1994 08:12:32 GMT
@@ -98,7 +100,7 @@ mod test {
 
         assert_eq!(
             headers.to_string(),
-            "Date: Tue, 15 Nov 1994 08:12:32 -0000\r\n"
+            "Date: Tue, 15 Nov 1994 08:12:32 +0000\r\n"
         );
     }
 
@@ -106,10 +108,10 @@ mod test {
     fn parse_date() {
         let mut headers = Headers::new();
 
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("Date"),
-            "Tue, 15 Nov 1994 08:12:31 -0000".to_string(),
-        );
+            "Tue, 15 Nov 1994 08:12:31 +0000".to_owned(),
+        ));
 
         assert_eq!(
             headers.get::<Date>(),
@@ -118,10 +120,10 @@ mod test {
             ))
         );
 
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("Date"),
-            "Tue, 15 Nov 1994 08:12:32 -0000".to_string(),
-        );
+            "Tue, 15 Nov 1994 08:12:32 +0000".to_owned(),
+        ));
 
         assert_eq!(
             headers.get::<Date>(),

src/message/header/mailbox.rs

@@ -1,4 +1,6 @@
-use super::{Header, HeaderName};
+use email_encoding::headers::writer::EmailWriter;
+
+use super::{Header, HeaderName, HeaderValue};
 use crate::{
     message::mailbox::{Mailbox, Mailboxes},
     BoxError,
@@ -12,7 +14,7 @@ pub trait MailboxesHeader {
 macro_rules! mailbox_header {
     ($(#[$doc:meta])*($type_name: ident, $header_name: expr)) => {
         $(#[$doc])*
-        #[derive(Debug, Clone, PartialEq)]
+        #[derive(Debug, Clone, PartialEq, Eq)]
         pub struct $type_name(Mailbox);
 
         impl Header for $type_name {
@@ -25,8 +27,15 @@ macro_rules! mailbox_header {
                 Ok(Self(mailbox))
             }
 
-            fn display(&self) -> String {
-                self.0.to_string()
+            fn display(&self) -> HeaderValue {
+                let mut encoded_value = String::new();
+                let line_len = $header_name.len() + ": ".len();
+                {
+                    let mut w = EmailWriter::new(&mut encoded_value, line_len, 0, false);
+                    self.0.encode(&mut w).expect("writing `Mailbox` returned an error");
+                }
+
+                HeaderValue::dangerous_new_pre_encoded(Self::name(), self.0.to_string(), encoded_value)
             }
         }
 
@@ -49,7 +58,7 @@ macro_rules! mailbox_header {
 macro_rules! mailboxes_header {
     ($(#[$doc:meta])*($type_name: ident, $header_name: expr)) => {
         $(#[$doc])*
-        #[derive(Debug, Clone, PartialEq)]
+        #[derive(Debug, Clone, PartialEq, Eq)]
         pub struct $type_name(pub(crate) Mailboxes);
 
         impl MailboxesHeader for $type_name {
@@ -68,8 +77,15 @@ macro_rules! mailboxes_header {
                 Ok(Self(mailbox))
             }
 
-            fn display(&self) -> String {
-                self.0.to_string()
+            fn display(&self) -> HeaderValue {
+                let mut encoded_value = String::new();
+                let line_len = $header_name.len() + ": ".len();
+                {
+                    let mut w = EmailWriter::new(&mut encoded_value, line_len, 0, false);
+                    self.0.encode(&mut w).expect("writing `Mailboxes` returned an error");
+                }
+
+                HeaderValue::dangerous_new_pre_encoded(Self::name(), self.0.to_string(), encoded_value)
             }
         }
 
@@ -160,8 +176,10 @@ mailboxes_header! {
 
 #[cfg(test)]
 mod test {
+    use pretty_assertions::assert_eq;
+
     use super::{From, Mailbox, Mailboxes};
-    use crate::message::header::{HeaderName, Headers};
+    use crate::message::header::{HeaderName, HeaderValue, Headers};
 
     #[test]
     fn format_single_without_name() {
@@ -175,12 +193,12 @@ mod test {
 
     #[test]
     fn format_single_with_name() {
-        let from = Mailboxes::new().with("K. <kayo@example.com>".parse().unwrap());
+        let from = Mailboxes::new().with("Kayo <kayo@example.com>".parse().unwrap());
 
         let mut headers = Headers::new();
         headers.set(From(from));
 
-        assert_eq!(headers.to_string(), "From: K. <kayo@example.com>\r\n");
+        assert_eq!(headers.to_string(), "From: Kayo <kayo@example.com>\r\n");
     }
 
     #[test]
@@ -201,7 +219,7 @@ mod test {
     #[test]
     fn format_multi_with_name() {
         let from = vec![
-            "K. <kayo@example.com>".parse().unwrap(),
+            "Kayo <kayo@example.com>".parse().unwrap(),
             "Pony P. <pony@domain.tld>".parse().unwrap(),
         ];
 
@@ -210,7 +228,7 @@ mod test {
 
         assert_eq!(
             headers.to_string(),
-            "From: K. <kayo@example.com>, Pony P. <pony@domain.tld>\r\n"
+            "From: Kayo <kayo@example.com>, \"Pony P.\" <pony@domain.tld>\r\n"
         );
     }
 
@@ -232,10 +250,10 @@ mod test {
         let from = vec!["kayo@example.com".parse().unwrap()].into();
 
         let mut headers = Headers::new();
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("From"),
-            "kayo@example.com".to_string(),
-        );
+            "kayo@example.com".to_owned(),
+        ));
 
         assert_eq!(headers.get::<From>(), Some(From(from)));
     }
@@ -245,10 +263,10 @@ mod test {
         let from = vec!["K. <kayo@example.com>".parse().unwrap()].into();
 
         let mut headers = Headers::new();
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("From"),
-            "K. <kayo@example.com>".to_string(),
-        );
+            "K. <kayo@example.com>".to_owned(),
+        ));
 
         assert_eq!(headers.get::<From>(), Some(From(from)));
     }
@@ -261,10 +279,10 @@ mod test {
         ];
 
         let mut headers = Headers::new();
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("From"),
-            "kayo@example.com, pony@domain.tld".to_string(),
-        );
+            "kayo@example.com, pony@domain.tld".to_owned(),
+        ));
 
         assert_eq!(headers.get::<From>(), Some(From(from.into())));
     }
@@ -277,11 +295,65 @@ mod test {
         ];
 
         let mut headers = Headers::new();
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("From"),
-            "K. <kayo@example.com>, Pony P. <pony@domain.tld>".to_string(),
-        );
+            "K. <kayo@example.com>, Pony P. <pony@domain.tld>".to_owned(),
+        ));
 
         assert_eq!(headers.get::<From>(), Some(From(from.into())));
     }
+
+    #[test]
+    fn parse_multi_with_name_containing_comma() {
+        let from: Vec<Mailbox> = vec![
+            "\"Test, test\" <1@example.com>".parse().unwrap(),
+            "\"Test2, test2\" <2@example.com>".parse().unwrap(),
+        ];
+
+        let mut headers = Headers::new();
+        headers.insert_raw(HeaderValue::new(
+            HeaderName::new_from_ascii_str("From"),
+            "\"Test, test\" <1@example.com>, \"Test2, test2\" <2@example.com>".to_owned(),
+        ));
+
+        assert_eq!(headers.get::<From>(), Some(From(from.into())));
+    }
+
+    #[test]
+    fn parse_multi_with_name_containing_double_quotes() {
+        let from: Vec<Mailbox> = vec![
+            "\"Test, test\" <1@example.com>".parse().unwrap(),
+            "\"Test2, \"test2\"\" <2@example.com>".parse().unwrap(),
+        ];
+
+        let mut headers = Headers::new();
+        headers.insert_raw(HeaderValue::new(
+            HeaderName::new_from_ascii_str("From"),
+            "\"Test, test\" <1@example.com>, \"Test2, \"test2\"\" <2@example.com>".to_owned(),
+        ));
+
+        assert_eq!(headers.get::<From>(), Some(From(from.into())));
+    }
+
+    #[test]
+    fn parse_multi_with_name_containing_comma_last_broken() {
+        let mut headers = Headers::new();
+        headers.insert_raw(HeaderValue::new(
+            HeaderName::new_from_ascii_str("From"),
+            "\"Test, test\" <1@example.com>, \"Test2, test2\"".to_owned(),
+        ));
+
+        assert_eq!(headers.get::<From>(), None);
+    }
+
+    #[test]
+    fn mailbox_format_address_with_angle_bracket() {
+        assert_eq!(
+            format!(
+                "{}",
+                Mailbox::new(Some("<3".into()), "i@love.example".parse().unwrap())
+            ),
+            r#""<3" <i@love.example>"#
+        );
+    }
 }

src/message/header/mod.rs

@@ -3,10 +3,12 @@
 use std::{
     borrow::Cow,
     error::Error,
-    fmt::{self, Display, Formatter},
+    fmt::{self, Display, Formatter, Write},
     ops::Deref,
 };
 
+use email_encoding::headers::writer::EmailWriter;
+
 pub use self::{
     content::*,
     content_disposition::ContentDisposition,
@@ -16,6 +18,7 @@ pub use self::{
     special::*,
     textual::*,
 };
+use super::EmailFormat;
 use crate::BoxError;
 
 mod content;
@@ -26,18 +29,21 @@ mod mailbox;
 mod special;
 mod textual;
 
+/// Represents an email header
+///
+/// Email header as defined in [RFC5322](https://datatracker.ietf.org/doc/html/rfc5322) and extensions.
 pub trait Header: Clone {
     fn name() -> HeaderName;
 
     fn parse(s: &str) -> Result<Self, BoxError>;
 
-    fn display(&self) -> String;
+    fn display(&self) -> HeaderValue;
 }
 
 /// A set of email headers
 #[derive(Debug, Clone, Default)]
 pub struct Headers {
-    headers: Vec<(HeaderName, String)>,
+    headers: Vec<HeaderValue>,
 }
 
 impl Headers {
@@ -61,17 +67,18 @@ impl Headers {
         }
     }
 
-    /// Returns a copy of an `Header` present in `Headers`
+    /// Returns a copy of a `Header` present in `Headers`
     ///
     /// Returns `None` if `Header` isn't present in `Headers`.
     pub fn get<H: Header>(&self) -> Option<H> {
-        self.get_raw(&H::name()).and_then(|raw| H::parse(raw).ok())
+        self.get_raw(&H::name())
+            .and_then(|raw_value| H::parse(raw_value).ok())
     }
 
     /// Sets `Header` into `Headers`, overriding `Header` if it
     /// was already present in `Headers`
     pub fn set<H: Header>(&mut self, header: H) {
-        self.insert_raw(H::name(), header.display());
+        self.insert_raw(header.display());
     }
 
     /// Remove `Header` from `Headers`, returning it
@@ -79,7 +86,7 @@ impl Headers {
     /// Returns `None` if `Header` isn't in `Headers`.
     pub fn remove<H: Header>(&mut self) -> Option<H> {
         self.remove_raw(&H::name())
-            .and_then(|(_name, raw)| H::parse(&raw).ok())
+            .and_then(|value| H::parse(&value.raw_value).ok())
     }
 
     /// Clears `Headers`, removing all headers from it
@@ -94,62 +101,42 @@ impl Headers {
     ///
     /// Returns `None` if `name` isn't present in `Headers`.
     pub fn get_raw(&self, name: &str) -> Option<&str> {
-        self.find_header(name).map(|(_name, value)| value)
+        self.find_header(name).map(|value| value.raw_value.as_str())
     }
 
     /// Inserts a raw header into `Headers`, overriding `value` if it
     /// was already present in `Headers`.
-    pub fn insert_raw(&mut self, name: HeaderName, value: String) {
-        match self.find_header_mut(&name) {
-            Some((_, current_value)) => {
+    pub fn insert_raw(&mut self, value: HeaderValue) {
+        match self.find_header_mut(&value.name) {
+            Some(current_value) => {
                 *current_value = value;
             }
             None => {
-                self.headers.push((name, value));
+                self.headers.push(value);
             }
         }
     }
 
-    /// Appends a raw header into `Headers`
-    ///
-    /// If a header with a name of `name` is already present,
-    /// appends `, ` + `value` to it's current value.
-    pub fn append_raw(&mut self, name: HeaderName, value: String) {
-        match self.find_header_mut(&name) {
-            Some((_name, prev_value)) => {
-                prev_value.push_str(", ");
-                prev_value.push_str(&value);
-            }
-            None => self.headers.push((name, value)),
-        }
-    }
-
     /// Remove a raw header from `Headers`, returning it
     ///
     /// Returns `None` if `name` isn't present in `Headers`.
-    pub fn remove_raw(&mut self, name: &str) -> Option<(HeaderName, String)> {
+    pub fn remove_raw(&mut self, name: &str) -> Option<HeaderValue> {
         self.find_header_index(name).map(|i| self.headers.remove(i))
     }
 
-    fn find_header(&self, name: &str) -> Option<(&HeaderName, &str)> {
-        self.headers
-            .iter()
-            .find(|&(name_, _value)| name.eq_ignore_ascii_case(name_))
-            .map(|t| (&t.0, t.1.as_str()))
+    pub(crate) fn find_header(&self, name: &str) -> Option<&HeaderValue> {
+        self.headers.iter().find(|value| name == value.name)
     }
 
-    fn find_header_mut(&mut self, name: &str) -> Option<(&HeaderName, &mut String)> {
-        self.headers
-            .iter_mut()
-            .find(|(name_, _value)| name.eq_ignore_ascii_case(name_))
-            .map(|t| (&t.0, &mut t.1))
+    fn find_header_mut(&mut self, name: &str) -> Option<&mut HeaderValue> {
+        self.headers.iter_mut().find(|value| name == value.name)
     }
 
     fn find_header_index(&self, name: &str) -> Option<usize> {
         self.headers
             .iter()
             .enumerate()
-            .find(|&(_i, (name_, _value))| name.eq_ignore_ascii_case(name_))
+            .find(|(_i, value)| name == value.name)
             .map(|(i, _)| i)
     }
 }
@@ -157,10 +144,10 @@ impl Headers {
 impl Display for Headers {
     /// Formats `Headers`, ready to put them into an email
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        for (name, value) in &self.headers {
-            Display::fmt(name, f)?;
+        for value in &self.headers {
+            f.write_str(&value.name)?;
             f.write_str(": ")?;
-            HeaderValueEncoder::encode(&name, &value, f)?;
+            f.write_str(&value.encoded_value)?;
             f.write_str("\r\n")?;
         }
 
@@ -168,21 +155,25 @@ impl Display for Headers {
     }
 }
 
+impl EmailFormat for Headers {
+    fn format<'a>(&'a self, out: &mut impl Extend<Cow<'a, [u8]>>) {
+        for value in &self.headers {
+            out.extend([
+                Cow::Borrowed(value.name.as_bytes()),
+                Cow::Borrowed(b": "),
+                Cow::Borrowed(value.encoded_value.as_bytes()),
+                Cow::Borrowed(b"\r\n"),
+            ]);
+        }
+    }
+}
+
 /// A possible error when converting a `HeaderName` from another type.
 // comes from `http` crate
 #[allow(missing_copy_implementations)]
-#[derive(Clone)]
-pub struct InvalidHeaderName {
-    _priv: (),
-}
-
-impl fmt::Debug for InvalidHeaderName {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("InvalidHeaderName")
-            // skip _priv noise
-            .finish()
-    }
-}
+#[derive(Debug, Clone)]
+#[non_exhaustive]
+pub struct InvalidHeaderName;
 
 impl fmt::Display for InvalidHeaderName {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -199,14 +190,11 @@ pub struct HeaderName(Cow<'static, str>);
 impl HeaderName {
     /// Creates a new header name
     pub fn new_from_ascii(ascii: String) -> Result<Self, InvalidHeaderName> {
-        if !ascii.is_empty()
-            && ascii.len() <= 76
-            && ascii.is_ascii()
-            && !ascii.contains(|c| c == ':' || c == ' ')
+        if !ascii.is_empty() && ascii.len() <= 76 && ascii.is_ascii() && !ascii.contains([':', ' '])
         {
             Ok(Self(Cow::Owned(ascii)))
         } else {
-            Err(InvalidHeaderName { _priv: () })
+            Err(InvalidHeaderName)
         }
     }
 
@@ -237,7 +225,7 @@ impl HeaderName {
 
 impl Display for HeaderName {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.write_str(&self)
+        f.write_str(self)
     }
 }
 
@@ -267,75 +255,102 @@ impl AsRef<str> for HeaderName {
 
 impl PartialEq<HeaderName> for HeaderName {
     fn eq(&self, other: &HeaderName) -> bool {
-        let s1: &str = self.as_ref();
-        let s2: &str = other.as_ref();
-        s1 == s2
+        self.eq_ignore_ascii_case(other)
     }
 }
 
 impl PartialEq<&str> for HeaderName {
     fn eq(&self, other: &&str) -> bool {
-        let s: &str = self.as_ref();
-        s == *other
+        self.eq_ignore_ascii_case(other)
     }
 }
 
 impl PartialEq<HeaderName> for &str {
     fn eq(&self, other: &HeaderName) -> bool {
-        let s: &str = other.as_ref();
-        *self == s
+        self.eq_ignore_ascii_case(other)
     }
 }
 
-const ENCODING_START_PREFIX: &str = "=?utf-8?b?";
-const ENCODING_END_SUFFIX: &str = "?=";
-const MAX_LINE_LEN: usize = 76;
+/// A safe for use header value
+#[derive(Debug, Clone, PartialEq)]
+pub struct HeaderValue {
+    name: HeaderName,
+    raw_value: String,
+    encoded_value: String,
+}
+
+impl HeaderValue {
+    /// Construct a new `HeaderValue` and encode it
+    ///
+    /// Takes the header `name` and the `raw_value` and encodes
+    /// it via `RFC2047` and line folds it.
+    ///
+    /// [`RFC2047`]: https://datatracker.ietf.org/doc/html/rfc2047
+    pub fn new(name: HeaderName, raw_value: String) -> Self {
+        let mut encoded_value = String::with_capacity(raw_value.len());
+        HeaderValueEncoder::encode(&name, &raw_value, &mut encoded_value).unwrap();
+
+        Self {
+            name,
+            raw_value,
+            encoded_value,
+        }
+    }
+
+    /// Construct a new `HeaderValue` using a pre-encoded header value
+    ///
+    /// This method is _extremely_ dangerous as it opens up
+    /// the encoder to header injection attacks, but is sometimes
+    /// acceptable for use if `encoded_value` contains only ascii
+    /// printable characters and is already line folded.
+    ///
+    /// When in doubt, use [`HeaderValue::new`].
+    pub fn dangerous_new_pre_encoded(
+        name: HeaderName,
+        raw_value: String,
+        encoded_value: String,
+    ) -> Self {
+        Self {
+            name,
+            raw_value,
+            encoded_value,
+        }
+    }
+
+    #[cfg(feature = "dkim")]
+    pub(crate) fn get_raw(&self) -> &str {
+        &self.raw_value
+    }
+
+    #[cfg(feature = "dkim")]
+    pub(crate) fn get_encoded(&self) -> &str {
+        &self.encoded_value
+    }
+}
 
 /// [RFC 1522](https://tools.ietf.org/html/rfc1522) header value encoder
-struct HeaderValueEncoder {
-    line_len: usize,
+struct HeaderValueEncoder<'a> {
+    writer: EmailWriter<'a>,
     encode_buf: String,
 }
 
-impl HeaderValueEncoder {
-    fn encode(name: &str, value: &str, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let (words_iter, encoder) = Self::new(name, value);
-        encoder.format(words_iter, f)
+impl<'a> HeaderValueEncoder<'a> {
+    fn encode(name: &str, value: &'a str, f: &'a mut impl fmt::Write) -> fmt::Result {
+        let encoder = Self::new(name, f);
+        encoder.format(value.split_inclusive(' '))
     }
 
-    fn new<'a>(name: &str, value: &'a str) -> (WordsPlusFillIterator<'a>, Self) {
-        (
-            WordsPlusFillIterator { s: value },
-            Self {
-                line_len: name.len() + ": ".len(),
-                encode_buf: String::new(),
-            },
-        )
+    fn new(name: &str, writer: &'a mut dyn Write) -> Self {
+        let line_len = name.len() + ": ".len();
+        let writer = EmailWriter::new(writer, line_len, 0, false);
+
+        Self {
+            writer,
+            encode_buf: String::new(),
+        }
     }
 
-    fn format(
-        mut self,
-        words_iter: WordsPlusFillIterator<'_>,
-        f: &mut fmt::Formatter<'_>,
-    ) -> fmt::Result {
-        /// Estimate if an encoded string of `len` would fix in an empty line
-        fn would_fit_new_line(len: usize) -> bool {
-            len < (MAX_LINE_LEN - " ".len())
-        }
-
-        /// Estimate how long a string of `len` would be after base64 encoding plus
-        /// adding the encoding prefix and suffix to it
-        fn base64_len(len: usize) -> usize {
-            ENCODING_START_PREFIX.len() + (len * 4 / 3 + 4) + ENCODING_END_SUFFIX.len()
-        }
-
-        /// Estimate how many more bytes we can fit in the current line
-        fn available_len_to_max_encode_len(len: usize) -> usize {
-            len.saturating_sub(
-                ENCODING_START_PREFIX.len() + (len * 3 / 4 + 4) + ENCODING_END_SUFFIX.len(),
-            )
-        }
-
+    fn format(mut self, words_iter: impl Iterator<Item = &'a str>) -> fmt::Result {
         for next_word in words_iter {
             let allowed = allowed_str(next_word);
 
@@ -343,206 +358,54 @@ impl HeaderValueEncoder {
                 // This word only contains allowed characters
 
                 // the next word is allowed, but we may have accumulated some words to encode
-                self.flush_encode_buf(f, true)?;
+                self.flush_encode_buf()?;
 
-                if next_word.len() > self.remaining_line_len() {
-                    // not enough space left on this line to encode word
-
-                    if self.something_written_to_this_line() && would_fit_new_line(next_word.len())
-                    {
-                        // word doesn't fit this line, but something had already been written to it,
-                        // and word would fit the next line, so go to a new line
-                        // so go to new line
-                        self.new_line(f)?;
-                    } else {
-                        // word neither fits this line and the next one, cut it
-                        // in the middle and make it fit
-
-                        let mut next_word = next_word;
-
-                        while !next_word.is_empty() {
-                            if self.remaining_line_len() == 0 {
-                                self.new_line(f)?;
-                            }
-
-                            let len = self.remaining_line_len().min(next_word.len());
-                            let first_part = &next_word[..len];
-                            next_word = &next_word[len..];
-
-                            f.write_str(first_part)?;
-                            self.line_len += first_part.len();
-                        }
-
-                        continue;
-                    }
-                }
-
-                // word fits, write it!
-                f.write_str(next_word)?;
-                self.line_len += next_word.len();
+                self.writer.folding().write_str(next_word)?;
             } else {
                 // This word contains unallowed characters
-
-                if self.remaining_line_len() >= base64_len(self.encode_buf.len() + next_word.len())
-                {
-                    // next_word fits
-                    self.encode_buf.push_str(next_word);
-                    continue;
-                }
-
-                // next_word doesn't fit this line
-
-                if would_fit_new_line(base64_len(next_word.len())) {
-                    // ...but it would fit the next one
-
-                    self.flush_encode_buf(f, false)?;
-                    self.new_line(f)?;
-
-                    self.encode_buf.push_str(next_word);
-                    continue;
-                }
-
-                // ...and also wouldn't fit the next one.
-                // chop it up into pieces
-
-                let mut next_word = next_word;
-
-                while !next_word.is_empty() {
-                    if self.remaining_line_len() <= base64_len(1) {
-                        self.flush_encode_buf(f, false)?;
-                        self.new_line(f)?;
-                    }
-
-                    let mut len = available_len_to_max_encode_len(self.remaining_line_len())
-                        .min(next_word.len());
-                    // avoid slicing on a char boundary
-                    while !next_word.is_char_boundary(len) {
-                        len += 1;
-                    }
-                    let first_part = &next_word[..len];
-                    next_word = &next_word[len..];
-
-                    self.encode_buf.push_str(first_part);
-                }
+                self.encode_buf.push_str(next_word);
             }
         }
 
-        self.flush_encode_buf(f, false)?;
+        self.flush_encode_buf()?;
 
         Ok(())
     }
 
-    /// Returns the number of bytes left for the current line
-    fn remaining_line_len(&self) -> usize {
-        MAX_LINE_LEN - self.line_len
-    }
-
-    /// Returns true if something has been written to the current line
-    fn something_written_to_this_line(&self) -> bool {
-        self.line_len > 1
-    }
-
-    fn flush_encode_buf(
-        &mut self,
-        f: &mut fmt::Formatter<'_>,
-        switching_to_allowed: bool,
-    ) -> fmt::Result {
-        use std::fmt::Write;
-
+    fn flush_encode_buf(&mut self) -> fmt::Result {
         if self.encode_buf.is_empty() {
             // nothing to encode
             return Ok(());
         }
 
-        let mut write_after = None;
+        let prefix = self.encode_buf.trim_end_matches(' ');
+        email_encoding::headers::rfc2047::encode(prefix, &mut self.writer)?;
 
-        if switching_to_allowed {
-            // If the next word only contains allowed characters, and the string to encode
-            // ends with a space, take the space out of the part to encode
-
-            let last_char = self.encode_buf.pop().expect("self.encode_buf isn't empty");
-            if is_space_like(last_char) {
-                write_after = Some(last_char);
-            } else {
-                self.encode_buf.push(last_char);
-            }
-        }
-
-        f.write_str(ENCODING_START_PREFIX)?;
-        let encoded = base64::display::Base64Display::with_config(
-            self.encode_buf.as_bytes(),
-            base64::STANDARD,
-        );
-        Display::fmt(&encoded, f)?;
-        f.write_str(ENCODING_END_SUFFIX)?;
-
-        self.line_len += ENCODING_START_PREFIX.len();
-        self.line_len += self.encode_buf.len() * 4 / 3 + 4;
-        self.line_len += ENCODING_END_SUFFIX.len();
-
-        if let Some(write_after) = write_after {
-            f.write_char(write_after)?;
-            self.line_len += 1;
+        // TODO: add a better API for doing this in email-encoding
+        let spaces = self.encode_buf.len() - prefix.len();
+        for _ in 0..spaces {
+            self.writer.space();
         }
 
         self.encode_buf.clear();
         Ok(())
     }
-
-    fn new_line(&mut self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("\r\n ")?;
-        self.line_len = 1;
-
-        Ok(())
-    }
-}
-
-/// Iterator yielding a string split space by space, but including all space
-/// characters between it and the next word
-struct WordsPlusFillIterator<'a> {
-    s: &'a str,
-}
-
-impl<'a> Iterator for WordsPlusFillIterator<'a> {
-    type Item = &'a str;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.s.is_empty() {
-            return None;
-        }
-
-        let next_word = self
-            .s
-            .char_indices()
-            .skip(1)
-            .skip_while(|&(_i, c)| !is_space_like(c))
-            .find(|&(_i, c)| !is_space_like(c))
-            .map(|(i, _)| i);
-
-        let word = &self.s[..next_word.unwrap_or_else(|| self.s.len())];
-        self.s = &self.s[word.len()..];
-        Some(word)
-    }
-}
-
-const fn is_space_like(c: char) -> bool {
-    c == ',' || c == ' '
 }
 
 fn allowed_str(s: &str) -> bool {
-    s.chars().all(allowed_char)
+    s.bytes().all(allowed_char)
 }
 
-const fn allowed_char(c: char) -> bool {
-    c >= 1 as char && c <= 9 as char
-        || c == 11 as char
-        || c == 12 as char
-        || c >= 14 as char && c <= 127 as char
+const fn allowed_char(c: u8) -> bool {
+    c >= 1 && c <= 9 || c == 11 || c == 12 || c >= 14 && c <= 127
 }
 
 #[cfg(test)]
 mod tests {
-    use super::{HeaderName, Headers};
+    use pretty_assertions::assert_eq;
+
+    use super::{HeaderName, HeaderValue, Headers, To};
+    use crate::message::Mailboxes;
 
     #[test]
     fn valid_headername() {
@@ -598,15 +461,69 @@ mod tests {
         let _ = HeaderName::new_from_ascii_str("");
     }
 
+    #[test]
+    fn headername_headername_eq() {
+        assert_eq!(
+            HeaderName::new_from_ascii_str("From"),
+            HeaderName::new_from_ascii_str("From")
+        );
+    }
+
+    #[test]
+    fn headername_str_eq() {
+        assert_eq!(HeaderName::new_from_ascii_str("From"), "From");
+    }
+
+    #[test]
+    fn str_headername_eq() {
+        assert_eq!("From", HeaderName::new_from_ascii_str("From"));
+    }
+
+    #[test]
+    fn headername_headername_eq_case_insensitive() {
+        assert_eq!(
+            HeaderName::new_from_ascii_str("From"),
+            HeaderName::new_from_ascii_str("from")
+        );
+    }
+
+    #[test]
+    fn headername_str_eq_case_insensitive() {
+        assert_eq!(HeaderName::new_from_ascii_str("From"), "from");
+    }
+
+    #[test]
+    fn str_headername_eq_case_insensitive() {
+        assert_eq!("from", HeaderName::new_from_ascii_str("From"));
+    }
+
+    #[test]
+    fn headername_headername_ne() {
+        assert_ne!(
+            HeaderName::new_from_ascii_str("From"),
+            HeaderName::new_from_ascii_str("To")
+        );
+    }
+
+    #[test]
+    fn headername_str_ne() {
+        assert_ne!(HeaderName::new_from_ascii_str("From"), "To");
+    }
+
+    #[test]
+    fn str_headername_ne() {
+        assert_ne!("From", HeaderName::new_from_ascii_str("To"));
+    }
+
     // names taken randomly from https://it.wikipedia.org/wiki/Pinco_Pallino
 
     #[test]
     fn format_ascii() {
         let mut headers = Headers::new();
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("To"),
-            "John Doe <example@example.com>, Jean Dupont <jean@example.com>".to_string(),
-        );
+            "John Doe <example@example.com>, Jean Dupont <jean@example.com>".to_owned(),
+        ));
 
         assert_eq!(
             headers.to_string(),
@@ -617,16 +534,16 @@ mod tests {
     #[test]
     fn format_ascii_with_folding() {
         let mut headers = Headers::new();
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("To"),
-            "Ascii <example@example.com>, John Doe <johndoe@example.com, John Smith <johnsmith@example.com>, Pinco Pallino <pincopallino@example.com>, Jemand <jemand@example.com>, Jean Dupont <jean@example.com>".to_string(),
-        );
+            "Ascii <example@example.com>, John Doe <johndoe@example.com, John Smith <johnsmith@example.com>, Pinco Pallino <pincopallino@example.com>, Jemand <jemand@example.com>, Jean Dupont <jean@example.com>".to_owned(),
+        ));
 
         assert_eq!(
             headers.to_string(),
             concat!(
-                "To: Ascii <example@example.com>, John Doe <johndoe@example.com, John Smith \r\n",
-                " <johnsmith@example.com>, Pinco Pallino <pincopallino@example.com>, Jemand \r\n",
+                "To: Ascii <example@example.com>, John Doe <johndoe@example.com, John Smith\r\n",
+                " <johnsmith@example.com>, Pinco Pallino <pincopallino@example.com>, Jemand\r\n",
                 " <jemand@example.com>, Jean Dupont <jean@example.com>\r\n"
             )
         );
@@ -635,16 +552,16 @@ mod tests {
     #[test]
     fn format_ascii_with_folding_long_line() {
         let mut headers = Headers::new();
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("Subject"),
-            "Hello! This is lettre, and this IsAVeryLongLineDoYouKnowWhatsGoingToHappenIGuessWeAreGoingToFindOut. Ok I guess that's it!".to_string()
-        );
+            "Hello! This is lettre, and this IsAVeryLongLineDoYouKnowWhatsGoingToHappenIGuessWeAreGoingToFindOut. Ok I guess that's it!".to_owned()
+        ));
 
         assert_eq!(
             headers.to_string(),
             concat!(
-                "Subject: Hello! This is lettre, and this \r\n ",
-                "IsAVeryLongLineDoYouKnowWhatsGoingToHappenIGuessWeAreGoingToFindOut. Ok I \r\n",
+                "Subject: Hello! This is lettre, and this\r\n",
+                " IsAVeryLongLineDoYouKnowWhatsGoingToHappenIGuessWeAreGoingToFindOut. Ok I\r\n",
                 " guess that's it!\r\n"
             )
         );
@@ -654,15 +571,17 @@ mod tests {
     fn format_ascii_with_folding_very_long_line() {
         let mut headers = Headers::new();
         headers.insert_raw(
+            HeaderValue::new(
             HeaderName::new_from_ascii_str("Subject"),
-            "Hello! IGuessTheLastLineWasntLongEnoughSoLetsTryAgainShallWeWhatDoYouThinkItsGoingToHappenIGuessWereAboutToFindOut! I don't know".to_string()
-        );
+            "Hello! IGuessTheLastLineWasntLongEnoughSoLetsTryAgainShallWeWhatDoYouThinkItsGoingToHappenIGuessWereAboutToFindOut! I don't know".to_owned()
+        ));
 
         assert_eq!(
             headers.to_string(),
             concat!(
-                "Subject: Hello! IGuessTheLastLineWasntLongEnoughSoLetsTryAgainShallWeWhatDoY\r\n",
-                " ouThinkItsGoingToHappenIGuessWereAboutToFindOut! I don't know\r\n",
+                "Subject: Hello!\r\n",
+                " IGuessTheLastLineWasntLongEnoughSoLetsTryAgainShallWeWhatDoYouThinkItsGoingToHappenIGuessWereAboutToFindOut!\r\n",
+                " I don't know\r\n",
             )
         );
     }
@@ -670,28 +589,24 @@ mod tests {
     #[test]
     fn format_ascii_with_folding_giant_word() {
         let mut headers = Headers::new();
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("Subject"),
-            "1abcdefghijklmnopqrstuvwxyz2abcdefghijklmnopqrstuvwxyz3abcdefghijklmnopqrstuvwxyz4abcdefghijklmnopqrstuvwxyz5abcdefghijklmnopqrstuvwxyz6abcdefghijklmnopqrstuvwxyz".to_string()
-        );
+            "1abcdefghijklmnopqrstuvwxyz2abcdefghijklmnopqrstuvwxyz3abcdefghijklmnopqrstuvwxyz4abcdefghijklmnopqrstuvwxyz5abcdefghijklmnopqrstuvwxyz6abcdefghijklmnopqrstuvwxyz".to_owned()
+        ));
 
         assert_eq!(
             headers.to_string(),
-            concat!(
-                "Subject: 1abcdefghijklmnopqrstuvwxyz2abcdefghijklmnopqrstuvwxyz3abcdefghijkl\r\n",
-                " mnopqrstuvwxyz4abcdefghijklmnopqrstuvwxyz5abcdefghijklmnopqrstuvwxyz6abcdef\r\n",
-                " ghijklmnopqrstuvwxyz\r\n",
-            )
+            "Subject: 1abcdefghijklmnopqrstuvwxyz2abcdefghijklmnopqrstuvwxyz3abcdefghijklmnopqrstuvwxyz4abcdefghijklmnopqrstuvwxyz5abcdefghijklmnopqrstuvwxyz6abcdefghijklmnopqrstuvwxyz\r\n",
         );
     }
 
     #[test]
     fn format_special() {
         let mut headers = Headers::new();
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("To"),
-            "Seán <sean@example.com>".to_string(),
-        );
+            "Seán <sean@example.com>".to_owned(),
+        ));
 
         assert_eq!(
             headers.to_string(),
@@ -702,10 +617,10 @@ mod tests {
     #[test]
     fn format_special_emoji() {
         let mut headers = Headers::new();
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("To"),
-            "🌎 <world@example.com>".to_string(),
-        );
+            "🌎 <world@example.com>".to_owned(),
+        ));
 
         assert_eq!(
             headers.to_string(),
@@ -716,19 +631,43 @@ mod tests {
     #[test]
     fn format_special_with_folding() {
         let mut headers = Headers::new();
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("To"),
-            "🌍 <world@example.com>, 🦆 Everywhere <ducks@example.com>, Иванов Иван Иванович <ivanov@example.com>, Jānis Bērziņš <janis@example.com>, Seán Ó Rudaí <sean@example.com>".to_string(),
-        );
+        let to = To::from(Mailboxes::from_iter([
+            "🌍 <world@example.com>".parse().unwrap(),
+            "🦆 Everywhere <ducks@example.com>".parse().unwrap(),
+            "Иванов Иван Иванович <ivanov@example.com>".parse().unwrap(),
+            "Jānis Bērziņš <janis@example.com>".parse().unwrap(),
+            "Seán Ó Rudaí <sean@example.com>".parse().unwrap(),
+        ]));
+        headers.set(to);
 
         assert_eq!(
             headers.to_string(),
             concat!(
-                "To: =?utf-8?b?8J+MjQ==?= <world@example.com>, =?utf-8?b?8J+mhg==?= \r\n",
-                " Everywhere <ducks@example.com>, =?utf-8?b?0JjQstCw0L3QvtCyIA==?=\r\n",
-                " =?utf-8?b?0JjQstCw0L0g0JjQstCw0L3QvtCy0LjRhw==?= <ivanov@example.com>, \r\n",
-                " =?utf-8?b?SsSBbmlzIELEk3J6acWGxaE=?= <janis@example.com>, \r\n",
-                " =?utf-8?b?U2XDoW4gw5MgUnVkYcOt?= <sean@example.com>\r\n"
+                "To: =?utf-8?b?8J+MjQ==?= <world@example.com>, =?utf-8?b?8J+mhiBFdmVyeXdo?=\r\n",
+                " =?utf-8?b?ZXJl?= <ducks@example.com>, =?utf-8?b?0JjQstCw0L3QvtCyINCY0LI=?=\r\n",
+                " =?utf-8?b?0LDQvSDQmNCy0LDQvdC+0LLQuNGH?= <ivanov@example.com>,\r\n",
+                " =?utf-8?b?SsSBbmlzIELEk3J6acWGxaE=?= <janis@example.com>, =?utf-8?b?U2U=?=\r\n",
+                " =?utf-8?b?w6FuIMOTIFJ1ZGHDrQ==?= <sean@example.com>\r\n",
+            )
+        );
+    }
+
+    #[test]
+    fn format_special_with_folding_raw() {
+        let mut headers = Headers::new();
+        headers.insert_raw(HeaderValue::new(
+            HeaderName::new_from_ascii_str("To"),
+            "🌍 <world@example.com>, 🦆 Everywhere <ducks@example.com>, Иванов Иван Иванович <ivanov@example.com>, Jānis Bērziņš <janis@example.com>, Seán Ó Rudaí <sean@example.com>".to_owned(),
+        ));
+
+        assert_eq!(
+            headers.to_string(),
+            concat!(
+                "To: =?utf-8?b?8J+MjQ==?= <world@example.com>, =?utf-8?b?8J+mhg==?=\r\n",
+                " Everywhere <ducks@example.com>, =?utf-8?b?0JjQstCw0L3QvtCyINCY0LLQsNC9?=\r\n",
+                " =?utf-8?b?INCY0LLQsNC90L7QstC40Yc=?= <ivanov@example.com>,\r\n",
+                " =?utf-8?b?SsSBbmlzIELEk3J6acWGxaE=?= <janis@example.com>, =?utf-8?b?U2U=?=\r\n",
+                " =?utf-8?b?w6FuIMOTIFJ1ZGHDrQ==?= <sean@example.com>\r\n",
             )
         );
     }
@@ -737,23 +676,31 @@ mod tests {
     fn format_slice_on_char_boundary_bug() {
         let mut headers = Headers::new();
         headers.insert_raw(
+            HeaderValue::new(
             HeaderName::new_from_ascii_str("Subject"),
-            "🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳".to_string(),
+            "🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳".to_owned(),)
         );
 
         assert_eq!(
             headers.to_string(),
-            "Subject: =?utf-8?b?8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz?=\r\n"
+            concat!(
+                "Subject: =?utf-8?b?8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz?=\r\n",
+                " =?utf-8?b?8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbM=?=\r\n",
+                " =?utf-8?b?8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbM=?=\r\n",
+                " =?utf-8?b?8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbM=?=\r\n",
+                " =?utf-8?b?8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbM=?=\r\n",
+                " =?utf-8?b?8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+lsw==?=\r\n"
+            )
         );
     }
 
     #[test]
     fn format_bad_stuff() {
         let mut headers = Headers::new();
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("Subject"),
-            "Hello! \r\n This is \" bad \0. 👋".to_string(),
-        );
+            "Hello! \r\n This is \" bad \0. 👋".to_owned(),
+        ));
 
         assert_eq!(
             headers.to_string(),
@@ -765,36 +712,57 @@ mod tests {
     fn format_everything() {
         let mut headers = Headers::new();
         headers.insert_raw(
+            HeaderValue::new(
             HeaderName::new_from_ascii_str("Subject"),
-            "Hello! This is lettre, and this IsAVeryLongLineDoYouKnowWhatsGoingToHappenIGuessWeAreGoingToFindOut. Ok I guess that's it!".to_string()
+            "Hello! This is lettre, and this IsAVeryLongLineDoYouKnowWhatsGoingToHappenIGuessWeAreGoingToFindOut. Ok I guess that's it!".to_owned()
+            )
         );
         headers.insert_raw(
+            HeaderValue::new(
             HeaderName::new_from_ascii_str("To"),
-            "🌍 <world@example.com>, 🦆 Everywhere <ducks@example.com>, Иванов Иван Иванович <ivanov@example.com>, Jānis Bērziņš <janis@example.com>, Seán Ó Rudaí <sean@example.com>".to_string(),
+            "🌍 <world@example.com>, 🦆 Everywhere <ducks@example.com>, Иванов Иван Иванович <ivanov@example.com>, Jānis Bērziņš <janis@example.com>, Seán Ó Rudaí <sean@example.com>".to_owned(),
+            )
         );
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("From"),
-            "Someone <somewhere@example.com>".to_string(),
-        );
-        headers.insert_raw(
+            "Someone <somewhere@example.com>".to_owned(),
+        ));
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("Content-Transfer-Encoding"),
-            "quoted-printable".to_string(),
-        );
+            "quoted-printable".to_owned(),
+        ));
 
         assert_eq!(
             headers.to_string(),
             concat!(
-                "Subject: Hello! This is lettre, and this \r\n",
-                " IsAVeryLongLineDoYouKnowWhatsGoingToHappenIGuessWeAreGoingToFindOut. Ok I \r\n",
+                "Subject: Hello! This is lettre, and this\r\n",
+                " IsAVeryLongLineDoYouKnowWhatsGoingToHappenIGuessWeAreGoingToFindOut. Ok I\r\n",
                 " guess that's it!\r\n",
-                "To: =?utf-8?b?8J+MjQ==?= <world@example.com>, =?utf-8?b?8J+mhg==?= \r\n",
-                " Everywhere <ducks@example.com>, =?utf-8?b?0JjQstCw0L3QvtCyIA==?=\r\n",
-                " =?utf-8?b?0JjQstCw0L0g0JjQstCw0L3QvtCy0LjRhw==?= <ivanov@example.com>, \r\n",
-                " =?utf-8?b?SsSBbmlzIELEk3J6acWGxaE=?= <janis@example.com>, \r\n",
-                " =?utf-8?b?U2XDoW4gw5MgUnVkYcOt?= <sean@example.com>\r\n",
+                "To: =?utf-8?b?8J+MjQ==?= <world@example.com>, =?utf-8?b?8J+mhg==?=\r\n",
+                " Everywhere <ducks@example.com>, =?utf-8?b?0JjQstCw0L3QvtCyINCY0LLQsNC9?=\r\n",
+                " =?utf-8?b?INCY0LLQsNC90L7QstC40Yc=?= <ivanov@example.com>,\r\n",
+                " =?utf-8?b?SsSBbmlzIELEk3J6acWGxaE=?= <janis@example.com>, =?utf-8?b?U2U=?=\r\n",
+                " =?utf-8?b?w6FuIMOTIFJ1ZGHDrQ==?= <sean@example.com>\r\n",
                 "From: Someone <somewhere@example.com>\r\n",
                 "Content-Transfer-Encoding: quoted-printable\r\n",
             )
         );
     }
+
+    #[test]
+    fn issue_653() {
+        let mut headers = Headers::new();
+        headers.insert_raw(HeaderValue::new(
+            HeaderName::new_from_ascii_str("Subject"),
+            "＋仮名 :a;go; ;;;;;s;;;;;;;;;;;;;;;;fffeinmjgggggggggｆっ".to_owned(),
+        ));
+
+        assert_eq!(
+            headers.to_string(),
+            concat!(
+                "Subject: =?utf-8?b?77yL5Luu5ZCN?= :a;go; =?utf-8?b?Ozs7OztzOzs7Ozs7Ozs7?=\r\n",
+                " =?utf-8?b?Ozs7Ozs7O2ZmZmVpbm1qZ2dnZ2dnZ2dn772G44Gj?=\r\n",
+            )
+        );
+    }
 }

src/message/header/special.rs

@@ -1,27 +1,33 @@
 use crate::{
-    message::header::{Header, HeaderName},
+    message::header::{Header, HeaderName, HeaderValue},
     BoxError,
 };
 
 /// Message format version, defined in [RFC2045](https://tools.ietf.org/html/rfc2045#section-4)
-#[derive(Debug, Copy, Clone, PartialEq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub struct MimeVersion {
     major: u8,
     minor: u8,
 }
 
+/// MIME version 1.0
+///
+/// Should be used in all MIME messages.
 pub const MIME_VERSION_1_0: MimeVersion = MimeVersion::new(1, 0);
 
 impl MimeVersion {
+    /// Build a new `MimeVersion` header
     pub const fn new(major: u8, minor: u8) -> Self {
         MimeVersion { major, minor }
     }
 
+    /// Get the `major` value of this `MimeVersion` header.
     #[inline]
     pub const fn major(self) -> u8 {
         self.major
     }
 
+    /// Get the `minor` value of this `MimeVersion` header.
     #[inline]
     pub const fn minor(self) -> u8 {
         self.minor
@@ -47,8 +53,9 @@ impl Header for MimeVersion {
         Ok(MimeVersion::new(major, minor))
     }
 
-    fn display(&self) -> String {
-        format!("{}.{}", self.major, self.minor)
+    fn display(&self) -> HeaderValue {
+        let val = format!("{}.{}", self.major, self.minor);
+        HeaderValue::dangerous_new_pre_encoded(Self::name(), val.clone(), val)
     }
 }
 
@@ -60,8 +67,10 @@ impl Default for MimeVersion {
 
 #[cfg(test)]
 mod test {
+    use pretty_assertions::assert_eq;
+
     use super::{MimeVersion, MIME_VERSION_1_0};
-    use crate::message::header::{HeaderName, Headers};
+    use crate::message::header::{HeaderName, HeaderValue, Headers};
 
     #[test]
     fn format_mime_version() {
@@ -80,17 +89,17 @@ mod test {
     fn parse_mime_version() {
         let mut headers = Headers::new();
 
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("MIME-Version"),
-            "1.0".to_string(),
-        );
+            "1.0".to_owned(),
+        ));
 
         assert_eq!(headers.get::<MimeVersion>(), Some(MIME_VERSION_1_0));
 
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("MIME-Version"),
-            "0.1".to_string(),
-        );
+            "0.1".to_owned(),
+        ));
 
         assert_eq!(headers.get::<MimeVersion>(), Some(MimeVersion::new(0, 1)));
     }

src/message/header/textual.rs

@@ -1,10 +1,10 @@
-use super::{Header, HeaderName};
+use super::{Header, HeaderName, HeaderValue};
 use crate::BoxError;
 
 macro_rules! text_header {
     ($(#[$attr:meta])* Header($type_name: ident, $header_name: expr )) => {
         $(#[$attr])*
-        #[derive(Debug, Clone, PartialEq)]
+        #[derive(Debug, Clone, PartialEq, Eq)]
         pub struct $type_name(String);
 
         impl Header for $type_name {
@@ -16,8 +16,8 @@ macro_rules! text_header {
                 Ok(Self(s.into()))
             }
 
-            fn display(&self) -> String {
-                self.0.clone()
+            fn display(&self) -> HeaderValue {
+             HeaderValue::new(Self::name(),   self.0.clone())
             }
         }
 
@@ -85,8 +85,10 @@ text_header! {
 
 #[cfg(test)]
 mod test {
+    use pretty_assertions::assert_eq;
+
     use super::Subject;
-    use crate::message::header::{HeaderName, Headers};
+    use crate::message::header::{HeaderName, HeaderValue, Headers};
 
     #[test]
     fn format_ascii() {
@@ -107,13 +109,24 @@ mod test {
         );
     }
 
+    #[test]
+    fn format_utf8_word() {
+        let mut headers = Headers::new();
+        headers.set(Subject("Administratör".into()));
+
+        assert_eq!(
+            headers.to_string(),
+            "Subject: =?utf-8?b?QWRtaW5pc3RyYXTDtnI=?=\r\n"
+        );
+    }
+
     #[test]
     fn parse_ascii() {
         let mut headers = Headers::new();
-        headers.insert_raw(
+        headers.insert_raw(HeaderValue::new(
             HeaderName::new_from_ascii_str("Subject"),
-            "Sample subject".to_string(),
-        );
+            "Sample subject".to_owned(),
+        ));
 
         assert_eq!(
             headers.get::<Subject>(),

src/message/mailbox/mod.rs

@@ -1,3 +1,4 @@
+mod parsers;
 #[cfg(feature = "serde")]
 mod serde;
 mod types;

src/message/mailbox/parsers/mod.rs

@@ -0,0 +1,5 @@
+mod rfc2234;
+mod rfc2822;
+mod rfc5336;
+
+pub(crate) use rfc2822::{mailbox, mailbox_list};

src/message/mailbox/parsers/rfc2234.rs

@@ -0,0 +1,32 @@
+//! Partial parsers implementation of [RFC2234]: Augmented BNF for
+//! Syntax Specifications: ABNF.
+//!
+//! [RFC2234]: https://datatracker.ietf.org/doc/html/rfc2234
+
+use chumsky::{error::Cheap, prelude::*};
+
+// 6.1  Core Rules
+// https://datatracker.ietf.org/doc/html/rfc2234#section-6.1
+
+// ALPHA          =  %x41-5A / %x61-7A   ; A-Z / a-z
+pub(super) fn alpha() -> impl Parser<char, char, Error = Cheap<char>> {
+    filter(|c: &char| c.is_ascii_alphabetic())
+}
+
+// DIGIT          =  %x30-39
+//                        ; 0-9
+pub(super) fn digit() -> impl Parser<char, char, Error = Cheap<char>> {
+    filter(|c: &char| c.is_ascii_digit())
+}
+
+// DQUOTE         =  %x22
+//                        ; " (Double Quote)
+pub(super) fn dquote() -> impl Parser<char, char, Error = Cheap<char>> {
+    just('"')
+}
+
+// WSP            =  SP / HTAB
+//                        ; white space
+pub(super) fn wsp() -> impl Parser<char, char, Error = Cheap<char>> {
+    choice((just(' '), just('\t')))
+}

src/message/mailbox/parsers/rfc2822.rs

@@ -0,0 +1,250 @@
+//! Partial parsers implementation of [RFC2822]: Internet Message
+//! Format.
+//!
+//! [RFC2822]: https://datatracker.ietf.org/doc/html/rfc2822
+
+use chumsky::{error::Cheap, prelude::*};
+
+use super::{rfc2234, rfc5336};
+
+// 3.2.1. Primitive Tokens
+// https://datatracker.ietf.org/doc/html/rfc2822#section-3.2.1
+
+// NO-WS-CTL       =       %d1-8 /         ; US-ASCII control characters
+//                         %d11 /          ;  that do not include the
+//                         %d12 /          ;  carriage return, line feed,
+//                         %d14-31 /       ;  and white space characters
+//                         %d127
+fn no_ws_ctl() -> impl Parser<char, char, Error = Cheap<char>> {
+    filter(|c| matches!(u32::from(*c), 1..=8 | 11 | 12 | 14..=31 | 127))
+}
+
+// text            =       %d1-9 /         ; Characters excluding CR and LF
+//                         %d11 /
+//                         %d12 /
+//                         %d14-127 /
+//                         obs-text
+fn text() -> impl Parser<char, char, Error = Cheap<char>> {
+    filter(|c| matches!(u32::from(*c), 1..=9 | 11 | 12 | 14..=127))
+}
+
+// 3.2.2. Quoted characters
+// https://datatracker.ietf.org/doc/html/rfc2822#section-3.2.2
+
+// quoted-pair     =       ("\" text) / obs-qp
+fn quoted_pair() -> impl Parser<char, char, Error = Cheap<char>> {
+    just('\\').ignore_then(text())
+}
+
+// 3.2.3. Folding white space and comments
+// https://datatracker.ietf.org/doc/html/rfc2822#section-3.2.3
+
+// FWS             =       ([*WSP CRLF] 1*WSP) /   ; Folding white space
+//                         obs-FWS
+pub fn fws() -> impl Parser<char, Option<char>, Error = Cheap<char>> {
+    rfc2234::wsp()
+        .or_not()
+        .then_ignore(rfc2234::wsp().ignored().repeated())
+}
+
+// CFWS            =       *([FWS] comment) (([FWS] comment) / FWS)
+pub fn cfws() -> impl Parser<char, Option<char>, Error = Cheap<char>> {
+    // TODO: comment are not currently supported, so for now a cfws is
+    // the same as a fws.
+    fws()
+}
+
+// 3.2.4. Atom
+// https://datatracker.ietf.org/doc/html/rfc2822#section-3.2.4
+
+// atext           =       ALPHA / DIGIT / ; Any character except controls,
+//                         "!" / "#" /     ;  SP, and specials.
+//                         "$" / "%" /     ;  Used for atoms
+//                         "&" / "'" /
+//                         "*" / "+" /
+//                         "-" / "/" /
+//                         "=" / "?" /
+//                         "^" / "_" /
+//                         "`" / "{" /
+//                         "|" / "}" /
+//                         "~"
+pub(super) fn atext() -> impl Parser<char, char, Error = Cheap<char>> {
+    choice((
+        rfc2234::alpha(),
+        rfc2234::digit(),
+        filter(|c| {
+            matches!(
+                *c,
+                '!' | '#'
+                    | '$'
+                    | '%'
+                    | '&'
+                    | '\''
+                    | '*'
+                    | '+'
+                    | '-'
+                    | '/'
+                    | '='
+                    | '?'
+                    | '^'
+                    | '_'
+                    | '`'
+                    | '{'
+                    | '|'
+                    | '}'
+                    | '~'
+            )
+        }),
+        // also allow non ASCII UTF8 chars
+        rfc5336::utf8_non_ascii(),
+    ))
+}
+
+// atom            =       [CFWS] 1*atext [CFWS]
+pub(super) fn atom() -> impl Parser<char, Vec<char>, Error = Cheap<char>> {
+    cfws().chain(atext().repeated().at_least(1))
+}
+
+// dot-atom        =       [CFWS] dot-atom-text [CFWS]
+pub fn dot_atom() -> impl Parser<char, Vec<char>, Error = Cheap<char>> {
+    cfws().chain(dot_atom_text())
+}
+
+// dot-atom-text   =       1*atext *("." 1*atext)
+pub fn dot_atom_text() -> impl Parser<char, Vec<char>, Error = Cheap<char>> {
+    atext().repeated().at_least(1).chain(
+        just('.')
+            .chain(atext().repeated().at_least(1))
+            .repeated()
+            .at_least(1)
+            .flatten(),
+    )
+}
+
+// 3.2.5. Quoted strings
+// https://datatracker.ietf.org/doc/html/rfc2822#section-3.2.5
+
+// qtext           =       NO-WS-CTL /     ; Non white space controls
+//
+//                         %d33 /          ; The rest of the US-ASCII
+//                         %d35-91 /       ;  characters not including "\"
+//                         %d93-126        ;  or the quote character
+fn qtext() -> impl Parser<char, char, Error = Cheap<char>> {
+    choice((
+        filter(|c| matches!(u32::from(*c), 33 | 35..=91 | 93..=126)),
+        no_ws_ctl(),
+    ))
+}
+
+// qcontent        =       qtext / quoted-pair
+pub(super) fn qcontent() -> impl Parser<char, char, Error = Cheap<char>> {
+    choice((qtext(), quoted_pair(), rfc5336::utf8_non_ascii()))
+}
+
+// quoted-string   =       [CFWS]
+//                         DQUOTE *([FWS] qcontent) [FWS] DQUOTE
+//                         [CFWS]
+fn quoted_string() -> impl Parser<char, Vec<char>, Error = Cheap<char>> {
+    rfc2234::dquote()
+        .ignore_then(fws().chain(qcontent()).repeated().flatten())
+        .then_ignore(text::whitespace())
+        .then_ignore(rfc2234::dquote())
+}
+
+// 3.2.6. Miscellaneous tokens
+// https://datatracker.ietf.org/doc/html/rfc2822#section-3.2.6
+
+// word            =       atom / quoted-string
+fn word() -> impl Parser<char, Vec<char>, Error = Cheap<char>> {
+    choice((quoted_string(), atom()))
+}
+
+// phrase          =       1*word / obs-phrase
+fn phrase() -> impl Parser<char, Vec<char>, Error = Cheap<char>> {
+    choice((obs_phrase(), word().repeated().at_least(1).flatten()))
+}
+
+// 3.4. Address Specification
+// https://datatracker.ietf.org/doc/html/rfc2822#section-3.4
+
+// mailbox         =       name-addr / addr-spec
+pub(crate) fn mailbox() -> impl Parser<char, (Option<String>, (String, String)), Error = Cheap<char>>
+{
+    choice((name_addr(), addr_spec().map(|addr| (None, addr))))
+        .padded()
+        .then_ignore(end())
+}
+
+// name-addr       =       [display-name] angle-addr
+fn name_addr() -> impl Parser<char, (Option<String>, (String, String)), Error = Cheap<char>> {
+    display_name().collect().or_not().then(angle_addr())
+}
+
+// angle-addr      =       [CFWS] "<" addr-spec ">" [CFWS] / obs-angle-addr
+fn angle_addr() -> impl Parser<char, (String, String), Error = Cheap<char>> {
+    addr_spec()
+        .delimited_by(just('<').ignored(), just('>').ignored())
+        .padded()
+}
+
+// display-name    =       phrase
+fn display_name() -> impl Parser<char, Vec<char>, Error = Cheap<char>> {
+    phrase()
+}
+
+// mailbox-list    =       (mailbox *("," mailbox)) / obs-mbox-list
+pub(crate) fn mailbox_list(
+) -> impl Parser<char, Vec<(Option<String>, (String, String))>, Error = Cheap<char>> {
+    choice((name_addr(), addr_spec().map(|addr| (None, addr))))
+        .separated_by(just(',').padded())
+        .then_ignore(end())
+}
+
+// 3.4.1. Addr-spec specification
+// https://datatracker.ietf.org/doc/html/rfc2822#section-3.4.1
+
+// addr-spec       =       local-part "@" domain
+pub fn addr_spec() -> impl Parser<char, (String, String), Error = Cheap<char>> {
+    local_part()
+        .collect()
+        .then_ignore(just('@'))
+        .then(domain().collect())
+}
+
+// local-part      =       dot-atom / quoted-string / obs-local-part
+pub fn local_part() -> impl Parser<char, Vec<char>, Error = Cheap<char>> {
+    choice((dot_atom(), quoted_string(), obs_local_part()))
+}
+
+// domain          =       dot-atom / domain-literal / obs-domain
+pub fn domain() -> impl Parser<char, Vec<char>, Error = Cheap<char>> {
+    // NOTE: omitting domain-literal since it may never be used
+    choice((dot_atom(), obs_domain()))
+}
+
+// 4.1. Miscellaneous obsolete tokens
+// https://datatracker.ietf.org/doc/html/rfc2822#section-4.1
+
+// obs-phrase      =       word *(word / "." / CFWS)
+fn obs_phrase() -> impl Parser<char, Vec<char>, Error = Cheap<char>> {
+    // NOTE: the CFWS is already captured by the word, no need to add
+    // it there.
+    word().chain(
+        choice((word(), just('.').repeated().exactly(1)))
+            .repeated()
+            .flatten(),
+    )
+}
+
+// 4.4. Obsolete Addressing
+// https://datatracker.ietf.org/doc/html/rfc2822#section-4.4
+
+// obs-local-part  =       word *("." word)
+pub fn obs_local_part() -> impl Parser<char, Vec<char>, Error = Cheap<char>> {
+    word().chain(just('.').chain(word()).repeated().flatten())
+}
+
+// obs-domain      =       atom *("." atom)
+pub fn obs_domain() -> impl Parser<char, Vec<char>, Error = Cheap<char>> {
+    atom().chain(just('.').chain(atom()).repeated().flatten())
+}

src/message/mailbox/parsers/rfc5336.rs

@@ -0,0 +1,17 @@
+//! Partial parsers implementation of [RFC5336]: SMTP Extension for
+//! Internationalized Email Addresses.
+//!
+//! [RFC5336]: https://datatracker.ietf.org/doc/html/rfc5336
+
+use chumsky::{error::Cheap, prelude::*};
+
+// 3.3.  Extended Mailbox Address Syntax
+// https://datatracker.ietf.org/doc/html/rfc5336#section-3.3
+
+// UTF8-non-ascii = UTF8-2 / UTF8-3 / UTF8-4
+// UTF8-2 =  <See Section 4 of RFC 3629>
+// UTF8-3 =  <See Section 4 of RFC 3629>
+// UTF8-4 =  <See Section 4 of RFC 3629>
+pub(super) fn utf8_non_ascii() -> impl Parser<char, char, Error = Cheap<char>> {
+    filter(|c: &char| c.len_utf8() > 1)
+}

src/message/mailbox/serde.rs

@@ -1,17 +1,19 @@
-use crate::message::{Mailbox, Mailboxes};
+use std::fmt::{Formatter, Result as FmtResult};
+
 use serde::{
     de::{Deserializer, Error as DeError, MapAccess, SeqAccess, Visitor},
     ser::Serializer,
     Deserialize, Serialize,
 };
-use std::fmt::{Formatter, Result as FmtResult};
+
+use crate::message::{Mailbox, Mailboxes};
 
 impl Serialize for Mailbox {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
-        serializer.serialize_str(&self.to_string())
+        serializer.collect_str(self)
     }
 }
 
@@ -109,7 +111,7 @@ impl Serialize for Mailboxes {
     where
         S: Serializer,
     {
-        serializer.serialize_str(&self.to_string())
+        serializer.collect_str(self)
     }
 }
 
@@ -152,9 +154,11 @@ impl<'de> Deserialize<'de> for Mailboxes {
 
 #[cfg(test)]
 mod test {
+    use pretty_assertions::assert_eq;
+    use serde_json::from_str;
+
     use super::*;
     use crate::address::Address;
-    use serde_json::from_str;
 
     #[test]
     fn parse_address_string() {
@@ -175,7 +179,7 @@ mod test {
     }
 
     #[test]
-    fn parse_mailbox_object_address_stirng() {
+    fn parse_mailbox_object_address_string() {
         let m: Mailbox = from_str(r#"{ "name": "Kai", "email": "kayo@example.com" }"#).unwrap();
         assert_eq!(m, "Kai <kayo@example.com>".parse().unwrap());
     }
@@ -194,7 +198,7 @@ mod test {
             from_str(r#""yin@dtb.com, Hei <hei@dtb.com>, Kai <kayo@example.com>""#).unwrap();
         assert_eq!(
             m,
-            "<yin@dtb.com>, Hei <hei@dtb.com>, Kai <kayo@example.com>"
+            "yin@dtb.com, Hei <hei@dtb.com>, Kai <kayo@example.com>"
                 .parse()
                 .unwrap()
         );
@@ -207,7 +211,7 @@ mod test {
                 .unwrap();
         assert_eq!(
             m,
-            "<yin@dtb.com>, Hei <hei@dtb.com>, Kai <kayo@example.com>"
+            "yin@dtb.com, Hei <hei@dtb.com>, Kai <kayo@example.com>"
                 .parse()
                 .unwrap()
         );

src/message/mailbox/types.rs

@@ -1,16 +1,21 @@
-use crate::address::{Address, AddressError};
 use std::{
-    convert::TryFrom,
     fmt::{Display, Formatter, Result as FmtResult, Write},
+    mem,
     slice::Iter,
     str::FromStr,
 };
 
+use chumsky::prelude::*;
+use email_encoding::headers::writer::EmailWriter;
+
+use super::parsers;
+use crate::address::{Address, AddressError};
+
 /// Represents an email address with an optional name for the sender/recipient.
 ///
 /// This type contains email address and the sender/recipient name (_Some Name \<user@domain.tld\>_ or _withoutname@domain.tld_).
 ///
-/// **NOTE**: Enable feature "serde" to be able serialize/deserialize it using [serde](https://serde.rs/).
+/// **NOTE**: Enable feature "serde" to be able to serialize/deserialize it using [serde](https://serde.rs/).
 ///
 /// # Examples
 ///
@@ -63,14 +68,30 @@ impl Mailbox {
     pub fn new(name: Option<String>, email: Address) -> Self {
         Mailbox { name, email }
     }
+
+    pub(crate) fn encode(&self, w: &mut EmailWriter<'_>) -> FmtResult {
+        if let Some(name) = &self.name {
+            email_encoding::headers::quoted_string::encode(name, w)?;
+            w.space();
+            w.write_char('<')?;
+        }
+
+        w.write_str(self.email.as_ref())?;
+
+        if self.name.is_some() {
+            w.write_char('>')?;
+        }
+
+        Ok(())
+    }
 }
 
 impl Display for Mailbox {
     fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
-        if let Some(ref name) = self.name {
+        if let Some(name) = &self.name {
             let name = name.trim();
             if !name.is_empty() {
-                f.write_str(&name)?;
+                write_word(f, name)?;
                 f.write_str(" <")?;
                 self.email.fmt(f)?;
                 return f.write_char('>');
@@ -89,40 +110,24 @@ impl<S: Into<String>, T: Into<String>> TryFrom<(S, T)> for Mailbox {
     }
 }
 
-/*
-impl<S: AsRef<&str>, T: AsRef<&str>> TryFrom<(S, T)> for Mailbox {
-    type Error = AddressError;
-
-    fn try_from(header: (S, T)) -> Result<Self, Self::Error> {
-        let (name, address) = header;
-        Ok(Mailbox::new(Some(name.as_ref()), address.as_ref().parse()?))
-    }
-}*/
-
 impl FromStr for Mailbox {
     type Err = AddressError;
 
     fn from_str(src: &str) -> Result<Mailbox, Self::Err> {
-        match (src.find('<'), src.find('>')) {
-            (Some(addr_open), Some(addr_close)) if addr_open < addr_close => {
-                let name = src.split_at(addr_open).0;
-                let addr_open = addr_open + 1;
-                let addr = src.split_at(addr_open).1.split_at(addr_close - addr_open).0;
-                let addr = addr.parse()?;
-                let name = name.trim();
-                let name = if name.is_empty() {
-                    None
-                } else {
-                    Some(name.into())
-                };
-                Ok(Mailbox::new(name, addr))
-            }
-            (Some(_), _) => Err(AddressError::Unbalanced),
-            _ => {
-                let addr = src.parse()?;
-                Ok(Mailbox::new(None, addr))
-            }
-        }
+        let (name, (user, domain)) = parsers::mailbox().parse(src).map_err(|_errs| {
+            // TODO: improve error management
+            AddressError::InvalidInput
+        })?;
+
+        let mailbox = Mailbox::new(name, Address::new(user, domain)?);
+
+        Ok(mailbox)
+    }
+}
+
+impl From<Address> for Mailbox {
+    fn from(value: Address) -> Self {
+        Self::new(None, value)
     }
 }
 
@@ -130,7 +135,7 @@ impl FromStr for Mailbox {
 ///
 /// This type contains a sequence of mailboxes (_Some Name \<user@domain.tld\>, Another Name \<other@domain.tld\>, withoutname@domain.tld, ..._).
 ///
-/// **NOTE**: Enable feature "serde" to be able serialize/deserialize it using [serde](https://serde.rs/).
+/// **NOTE**: Enable feature "serde" to be able to serialize/deserialize it using [serde](https://serde.rs/).
 #[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
 pub struct Mailboxes(Vec<Mailbox>);
 
@@ -250,6 +255,20 @@ impl Mailboxes {
     pub fn iter(&self) -> Iter<'_, Mailbox> {
         self.0.iter()
     }
+
+    pub(crate) fn encode(&self, w: &mut EmailWriter<'_>) -> FmtResult {
+        let mut first = true;
+        for mailbox in self.iter() {
+            if !mem::take(&mut first) {
+                w.write_char(',')?;
+                w.space();
+            }
+
+            mailbox.encode(w)?;
+        }
+
+        Ok(())
+    }
 }
 
 impl Default for Mailboxes {
@@ -282,6 +301,18 @@ impl From<Mailboxes> for Vec<Mailbox> {
     }
 }
 
+impl FromIterator<Mailbox> for Mailboxes {
+    fn from_iter<T: IntoIterator<Item = Mailbox>>(iter: T) -> Self {
+        Self(Vec::from_iter(iter))
+    }
+}
+
+impl Extend<Mailbox> for Mailboxes {
+    fn extend<T: IntoIterator<Item = Mailbox>>(&mut self, iter: T) {
+        self.0.extend(iter);
+    }
+}
+
 impl IntoIterator for Mailboxes {
     type Item = Mailbox;
     type IntoIter = ::std::vec::IntoIter<Mailbox>;
@@ -291,14 +322,6 @@ impl IntoIterator for Mailboxes {
     }
 }
 
-impl Extend<Mailbox> for Mailboxes {
-    fn extend<T: IntoIterator<Item = Mailbox>>(&mut self, iter: T) {
-        for elem in iter {
-            self.0.push(elem);
-        }
-    }
-}
-
 impl Display for Mailboxes {
     fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         let mut iter = self.iter();
@@ -320,17 +343,110 @@ impl FromStr for Mailboxes {
     type Err = AddressError;
 
     fn from_str(src: &str) -> Result<Self, Self::Err> {
-        src.split(',')
-            .map(|m| m.trim().parse())
-            .collect::<Result<Vec<_>, _>>()
-            .map(Mailboxes)
+        let mut mailboxes = Vec::new();
+
+        let parsed_mailboxes = parsers::mailbox_list().parse(src).map_err(|_errs| {
+            // TODO: improve error management
+            AddressError::InvalidInput
+        })?;
+
+        for (name, (user, domain)) in parsed_mailboxes {
+            mailboxes.push(Mailbox::new(name, Address::new(user, domain)?))
+        }
+
+        Ok(Mailboxes(mailboxes))
+    }
+}
+
+// https://datatracker.ietf.org/doc/html/rfc2822#section-3.2.6
+fn write_word(f: &mut Formatter<'_>, s: &str) -> FmtResult {
+    if s.as_bytes().iter().copied().all(is_valid_atom_char) {
+        f.write_str(s)
+    } else {
+        // Quoted string: https://datatracker.ietf.org/doc/html/rfc2822#section-3.2.5
+        f.write_char('"')?;
+        for c in s.chars() {
+            write_quoted_string_char(f, c)?;
+        }
+        f.write_char('"')?;
+
+        Ok(())
+    }
+}
+
+// https://datatracker.ietf.org/doc/html/rfc2822#section-3.2.4
+fn is_valid_atom_char(c: u8) -> bool {
+    matches!(c,
+		// Not really allowed but can be inserted between atoms.
+		b'\t' |
+		b' ' |
+
+		b'!' |
+		b'#' |
+		b'$' |
+		b'%' |
+		b'&' |
+		b'\'' |
+		b'*' |
+		b'+' |
+		b'-' |
+		b'/' |
+		b'0'..=b'8' |
+		b'=' |
+		b'?' |
+		b'A'..=b'Z' |
+		b'^' |
+		b'_' |
+		b'`' |
+		b'a'..=b'z' |
+		b'{' |
+		b'|' |
+		b'}' |
+		b'~' |
+
+		// Not technically allowed but will be escaped into allowed characters.
+		128..=255)
+}
+
+// https://datatracker.ietf.org/doc/html/rfc2822#section-3.2.5
+fn write_quoted_string_char(f: &mut Formatter<'_>, c: char) -> FmtResult {
+    match c {
+        // Can not be encoded.
+        '\n' | '\r' => Err(std::fmt::Error),
+
+        // Note, not qcontent but can be put before or after any qcontent.
+        '\t' | ' ' => f.write_char(c),
+
+        c if match c as u32 {
+            // NO-WS-CTL: https://datatracker.ietf.org/doc/html/rfc2822#section-3.2.1
+            1..=8 | 11 | 12 | 14..=31 | 127 |
+
+            // The rest of the US-ASCII except \ and "
+            33 |
+            35..=91 |
+            93..=126 |
+
+            // Non-ascii characters will be escaped separately later.
+            128.. => true,
+            _ => false,
+        } =>
+        {
+            f.write_char(c)
+        }
+
+        _ => {
+            // quoted-pair https://datatracker.ietf.org/doc/html/rfc2822#section-3.2.2
+            f.write_char('\\')?;
+            f.write_char(c)
+        }
     }
 }
 
 #[cfg(test)]
 mod test {
+    use pretty_assertions::assert_eq;
+
     use super::Mailbox;
-    use std::convert::TryInto;
 
     #[test]
     fn mailbox_format_address_only() {
@@ -350,7 +466,63 @@ mod test {
                 "{}",
                 Mailbox::new(Some("K.".into()), "kayo@example.com".parse().unwrap())
             ),
-            "K. <kayo@example.com>"
+            "\"K.\" <kayo@example.com>"
+        );
+    }
+
+    #[test]
+    fn mailbox_format_address_with_comma() {
+        assert_eq!(
+            format!(
+                "{}",
+                Mailbox::new(
+                    Some("Last, First".into()),
+                    "kayo@example.com".parse().unwrap()
+                )
+            ),
+            r#""Last, First" <kayo@example.com>"#
+        );
+    }
+
+    #[test]
+    fn mailbox_format_address_with_comma_and_non_ascii() {
+        assert_eq!(
+            format!(
+                "{}",
+                Mailbox::new(
+                    Some("Laşt, First".into()),
+                    "kayo@example.com".parse().unwrap()
+                )
+            ),
+            r#""Laşt, First" <kayo@example.com>"#
+        );
+    }
+
+    #[test]
+    fn mailbox_format_address_with_comma_and_quoted_non_ascii() {
+        assert_eq!(
+            format!(
+                "{}",
+                Mailbox::new(
+                    Some(r#"Laşt, "First""#.into()),
+                    "kayo@example.com".parse().unwrap()
+                )
+            ),
+            r#""Laşt, \"First\"" <kayo@example.com>"#
+        );
+    }
+
+    #[test]
+    fn mailbox_format_address_with_color() {
+        assert_eq!(
+            format!(
+                "{}",
+                Mailbox::new(
+                    Some("Chris's Wiki :: blog".into()),
+                    "kayo@example.com".parse().unwrap()
+                )
+            ),
+            r#""Chris's Wiki :: blog" <kayo@example.com>"#
         );
     }
 
@@ -372,7 +544,7 @@ mod test {
                 "{}",
                 Mailbox::new(Some(" K. ".into()), "kayo@example.com".parse().unwrap())
             ),
-            "K. <kayo@example.com>"
+            "\"K.\" <kayo@example.com>"
         );
     }
 
@@ -384,6 +556,14 @@ mod test {
         );
     }
 
+    #[test]
+    fn parse_address_only_trim() {
+        assert_eq!(
+            " kayo@example.com ".parse(),
+            Ok(Mailbox::new(None, "kayo@example.com".parse().unwrap()))
+        );
+    }
+
     #[test]
     fn parse_address_with_name() {
         assert_eq!(
@@ -395,6 +575,17 @@ mod test {
         );
     }
 
+    #[test]
+    fn parse_address_with_name_trim() {
+        assert_eq!(
+            " K. <kayo@example.com> ".parse(),
+            Ok(Mailbox::new(
+                Some("K.".into()),
+                "kayo@example.com".parse().unwrap()
+            ))
+        );
+    }
+
     #[test]
     fn parse_address_with_empty_name() {
         assert_eq!(
@@ -406,7 +597,7 @@ mod test {
     #[test]
     fn parse_address_with_empty_name_trim() {
         assert_eq!(
-            " <kayo@example.com>".parse(),
+            " <kayo@example.com> ".parse(),
             Ok(Mailbox::new(None, "kayo@example.com".parse().unwrap()))
         );
     }
@@ -414,7 +605,7 @@ mod test {
     #[test]
     fn parse_address_from_tuple() {
         assert_eq!(
-            ("K.".to_string(), "kayo@example.com".to_string()).try_into(),
+            ("K.".to_owned(), "kayo@example.com".to_owned()).try_into(),
             Ok(Mailbox::new(
                 Some("K.".into()),
                 "kayo@example.com".parse().unwrap()

src/message/mimebody.rs

@@ -1,11 +1,11 @@
-use std::io::Write;
+use std::{borrow::Cow, iter::repeat_with, sync::Arc};
+
+use mime::Mime;
 
 use crate::message::{
     header::{self, ContentTransferEncoding, ContentType, Header, Headers},
     EmailFormat, IntoBody,
 };
-use mime::Mime;
-use std::iter::repeat_with;
 
 /// MIME part variants
 #[derive(Debug, Clone)]
@@ -17,8 +17,18 @@ pub(super) enum Part {
     Multi(MultiPart),
 }
 
+impl Part {
+    #[cfg(feature = "dkim")]
+    pub(super) fn format_body(&self, out: &mut Vec<u8>) {
+        match self {
+            Part::Single(part) => part.format_body(out),
+            Part::Multi(part) => part.format_body(out),
+        }
+    }
+}
+
 impl EmailFormat for Part {
-    fn format(&self, out: &mut Vec<u8>) {
+    fn format<'a>(&'a self, out: &mut impl Extend<Cow<'a, [u8]>>) {
         match self {
             Part::Single(part) => part.format(out),
             Part::Multi(part) => part.format(out),
@@ -61,7 +71,7 @@ impl SinglePartBuilder {
 
         SinglePart {
             headers: self.headers,
-            body: body.into_vec(),
+            body: body.into_inner(),
         }
     }
 }
@@ -90,7 +100,7 @@ impl Default for SinglePartBuilder {
 #[derive(Debug, Clone)]
 pub struct SinglePart {
     headers: Headers,
-    body: Vec<u8>,
+    body: Arc<[u8]>,
 }
 
 impl SinglePart {
@@ -100,14 +110,14 @@ impl SinglePart {
         SinglePartBuilder::new()
     }
 
-    /// Directly create a `SinglePart` from an plain UTF-8 content
+    /// Directly create a `SinglePart` from a plain UTF-8 content
     pub fn plain<T: IntoBody>(body: T) -> Self {
         Self::builder()
             .header(header::ContentType::TEXT_PLAIN)
             .body(body)
     }
 
-    /// Directly create a `SinglePart` from an UTF-8 HTML content
+    /// Directly create a `SinglePart` from a UTF-8 HTML content
     pub fn html<T: IntoBody>(body: T) -> Self {
         Self::builder()
             .header(header::ContentType::TEXT_HTML)
@@ -128,19 +138,18 @@ impl SinglePart {
 
     /// Get message content formatted for sending
     pub fn formatted(&self) -> Vec<u8> {
-        let mut out = Vec::new();
-        self.format(&mut out);
-        out
+        self.format_to_vec()
     }
 }
 
 impl EmailFormat for SinglePart {
-    fn format(&self, out: &mut Vec<u8>) {
-        write!(out, "{}", self.headers)
-            .expect("A Write implementation panicked while formatting headers");
-        out.extend_from_slice(b"\r\n");
-        out.extend_from_slice(&self.body);
-        out.extend_from_slice(b"\r\n");
+    fn format<'a>(&'a self, out: &mut impl Extend<Cow<'a, [u8]>>) {
+        self.headers.format(out);
+        out.extend([
+            Cow::Borrowed("\r\n".as_bytes()),
+            Cow::Borrowed(&self.body),
+            Cow::Borrowed(b"\r\n"),
+        ]);
     }
 }
 
@@ -149,17 +158,17 @@ impl EmailFormat for SinglePart {
 pub enum MultiPartKind {
     /// Mixed kind to combine unrelated content parts
     ///
-    /// For example this kind can be used to mix email message and attachments.
+    /// For example, this kind can be used to mix an email message and attachments.
     Mixed,
 
     /// Alternative kind to join several variants of same email contents.
     ///
-    /// That kind is recommended to use for joining plain (text) and rich (HTML) messages into single email message.
+    /// That kind is recommended to use for joining plain (text) and rich (HTML) messages into a single email message.
     Alternative,
 
     /// Related kind to mix content and related resources.
     ///
-    /// For example, you can include images into HTML content using that.
+    /// For example, you can include images in HTML content using that.
     Related,
 
     /// Encrypted kind for encrypted messages
@@ -190,9 +199,9 @@ impl MultiPartKind {
             },
             boundary,
             match self {
-                Self::Encrypted { protocol } => format!("; protocol=\"{}\"", protocol),
+                Self::Encrypted { protocol } => format!("; protocol=\"{protocol}\""),
                 Self::Signed { protocol, micalg } =>
-                    format!("; protocol=\"{}\"; micalg=\"{}\"", protocol, micalg),
+                    format!("; protocol=\"{protocol}\"; micalg=\"{micalg}\""),
                 _ => String::new(),
             }
         )
@@ -369,37 +378,45 @@ impl MultiPart {
 
     /// Get message content formatted for SMTP
     pub fn formatted(&self) -> Vec<u8> {
-        let mut out = Vec::new();
-        self.format(&mut out);
-        out
+        self.format_to_vec()
+    }
+
+    /// Format only the multipart body
+    fn format_body<'a>(&'a self, out: &mut impl Extend<Cow<'a, [u8]>>) {
+        let boundary = self.boundary();
+
+        for part in &self.parts {
+            out.extend([
+                Cow::Borrowed("--".as_bytes()),
+                // FIXME: this clone shouldn't exist
+                Cow::Owned(boundary.clone().into()),
+                Cow::Borrowed("\r\n".as_bytes()),
+            ]);
+            part.format(out);
+        }
+
+        out.extend([
+            Cow::Borrowed("--".as_bytes()),
+            Cow::Owned(boundary.into()),
+            Cow::Borrowed("--\r\n".as_bytes()),
+        ]);
     }
 }
 
 impl EmailFormat for MultiPart {
-    fn format(&self, out: &mut Vec<u8>) {
-        write!(out, "{}", self.headers)
-            .expect("A Write implementation panicked while formatting headers");
-        out.extend_from_slice(b"\r\n");
+    fn format<'a>(&'a self, out: &mut impl Extend<Cow<'a, [u8]>>) {
+        self.headers.format(out);
+        out.extend([Cow::Borrowed("\r\n".as_bytes())]);
 
-        let boundary = self.boundary();
-
-        for part in &self.parts {
-            out.extend_from_slice(b"--");
-            out.extend_from_slice(boundary.as_bytes());
-            out.extend_from_slice(b"\r\n");
-            part.format(out);
-        }
-
-        out.extend_from_slice(b"--");
-        out.extend_from_slice(boundary.as_bytes());
-        out.extend_from_slice(b"--\r\n");
+        self.format_body(out);
     }
 }
 
 #[cfg(test)]
 mod test {
+    use pretty_assertions::assert_eq;
+
     use super::*;
-    use crate::message::header;
 
     #[test]
     fn single_part_binary() {
@@ -477,7 +494,7 @@ mod test {
         assert_eq!(
             String::from_utf8(part.formatted()).unwrap(),
             concat!(
-                "Content-Type: multipart/mixed; \r\n",
+                "Content-Type: multipart/mixed;\r\n",
                 " boundary=\"0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\"\r\n",
                 "\r\n",
                 "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
@@ -524,8 +541,8 @@ mod test {
         assert_eq!(
             String::from_utf8(part.formatted()).unwrap(),
             concat!(
-                "Content-Type: multipart/encrypted; \r\n",
-                " boundary=\"0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\"; \r\n",
+                "Content-Type: multipart/encrypted;\r\n",
+                " boundary=\"0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\";\r\n",
                 " protocol=\"application/pgp-encrypted\"\r\n",
                 "\r\n",
                 "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
@@ -580,8 +597,8 @@ mod test {
         assert_eq!(
             String::from_utf8(part.formatted()).unwrap(),
             concat!(
-                "Content-Type: multipart/signed; \r\n",
-                " boundary=\"0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\"; \r\n",
+                "Content-Type: multipart/signed;\r\n",
+                " boundary=\"0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\";\r\n",
                 " protocol=\"application/pgp-signature\";",
                 " micalg=\"pgp-sha256\"\r\n",
                 "\r\n",
@@ -622,7 +639,7 @@ mod test {
                              .body(String::from("<p>Текст <em>письма</em> в <a href=\"https://ru.wikipedia.org/wiki/Юникод\">уникоде</a><p>")));
 
         assert_eq!(String::from_utf8(part.formatted()).unwrap(),
-                   concat!("Content-Type: multipart/alternative; \r\n",
+                   concat!("Content-Type: multipart/alternative;\r\n",
                            " boundary=\"0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\"\r\n",
                            "\r\n",
                            "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
@@ -660,11 +677,11 @@ mod test {
                              .body(String::from("int main() { return 0; }")));
 
         assert_eq!(String::from_utf8(part.formatted()).unwrap(),
-                   concat!("Content-Type: multipart/mixed; \r\n",
+                   concat!("Content-Type: multipart/mixed;\r\n",
                            " boundary=\"0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\"\r\n",
                            "\r\n",
                            "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
-                           "Content-Type: multipart/related; \r\n",
+                           "Content-Type: multipart/related;\r\n",
                            " boundary=\"0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\"\r\n",
                            "\r\n",
                            "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",

src/message/mod.rs

@@ -4,15 +4,8 @@
 //!
 //! This section demonstrates how to build 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>
 //!
 //!
@@ -21,7 +14,7 @@
 //! The easiest way of creating a message, which uses a plain text body.
 //!
 //! ```rust
-//! use lettre::message::Message;
+//! use lettre::message::{header::ContentType, Message};
 //!
 //! # use std::error::Error;
 //! # fn main() -> Result<(), Box<dyn Error>> {
@@ -30,6 +23,7 @@
 //!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
 //!     .to("Hei <hei@domain.tld>".parse()?)
 //!     .subject("Happy new year")
+//!     .header(ContentType::TEXT_PLAIN)
 //!     .body(String::from("Be happy!"))?;
 //! # Ok(())
 //! # }
@@ -45,6 +39,7 @@
 //! To: Hei <hei@domain.tld>
 //! Subject: Happy new year
 //! Date: Sat, 12 Dec 2020 16:33:19 GMT
+//! Content-Type: text/plain; charset=utf-8
 //! Content-Transfer-Encoding: 7bit
 //!
 //! Be happy!
@@ -113,9 +108,10 @@
 //!
 //! ```rust
 //! # use std::error::Error;
-//! use lettre::message::{header, Attachment, Body, Message, MultiPart, SinglePart};
 //! use std::fs;
 //!
+//! use lettre::message::{header, Attachment, Body, Message, MultiPart, SinglePart};
+//!
 //! # fn main() -> Result<(), Box<dyn Error>> {
 //! let image = fs::read("docs/lettre.png")?;
 //! // this image_body can be cloned and reused between emails.
@@ -202,15 +198,19 @@
 //! ```
 //! </details>
 
-use std::{convert::TryFrom, io::Write, iter, time::SystemTime};
+use std::{borrow::Cow, iter, sync::Arc, time::SystemTime};
 
 pub use attachment::Attachment;
 pub use body::{Body, IntoBody, MaybeString};
+#[cfg(feature = "dkim")]
+pub use dkim::*;
 pub use mailbox::*;
 pub use mimebody::*;
 
 mod attachment;
 mod body;
+#[cfg(feature = "dkim")]
+pub mod dkim;
 pub mod header;
 mod mailbox;
 mod mimebody;
@@ -226,7 +226,23 @@ const DEFAULT_MESSAGE_ID_DOMAIN: &str = "localhost";
 /// Something that can be formatted as an email message
 trait EmailFormat {
     // Use a writer?
-    fn format(&self, out: &mut Vec<u8>);
+    fn format<'a>(&'a self, out: &mut impl Extend<Cow<'a, [u8]>>);
+
+    fn format_to_vec(&self) -> Vec<u8> {
+        struct Formatter(Vec<u8>);
+
+        impl<'a> Extend<Cow<'a, [u8]>> for Formatter {
+            fn extend<T: IntoIterator<Item = Cow<'a, [u8]>>>(&mut self, iter: T) {
+                for chunk in iter {
+                    self.0.extend_from_slice(&chunk);
+                }
+            }
+        }
+
+        let mut formatted = Formatter(Vec::new());
+        self.format(&mut formatted);
+        formatted.0
+    }
 }
 
 /// A builder for messages
@@ -234,6 +250,7 @@ trait EmailFormat {
 pub struct MessageBuilder {
     headers: Headers,
     envelope: Option<Envelope>,
+    drop_bcc: bool,
 }
 
 impl MessageBuilder {
@@ -242,24 +259,26 @@ impl MessageBuilder {
         Self {
             headers: Headers::new(),
             envelope: None,
+            drop_bcc: true,
         }
     }
 
-    /// Set custom header to message
-    pub fn header<H: Header>(mut self, header: H) -> Self {
-        self.headers.set(header);
-        self
+    /// Set or add mailbox to `From` header
+    ///
+    /// Defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.2).
+    ///
+    /// Shortcut for `self.mailbox(header::From(mbox))`.
+    pub fn from(self, mbox: Mailbox) -> Self {
+        self.mailbox(header::From::from(Mailboxes::from(mbox)))
     }
 
-    /// Add mailbox to header
-    pub fn mailbox<H: Header + MailboxesHeader>(self, header: H) -> Self {
-        match self.headers.get::<H>() {
-            Some(mut header_) => {
-                header_.join_mailboxes(header);
-                self.header(header_)
-            }
-            None => self.header(header),
-        }
+    /// Set `Sender` header. Should be used when providing several `From` mailboxes.
+    ///
+    /// Defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.2).
+    ///
+    /// Shortcut for `self.header(header::Sender(mbox))`.
+    pub fn sender(self, mbox: Mailbox) -> Self {
+        self.header(header::Sender::from(mbox))
     }
 
     /// Add `Date` header to message
@@ -277,41 +296,6 @@ impl MessageBuilder {
         self.date(SystemTime::now())
     }
 
-    /// Set `Subject` header to message
-    ///
-    /// Shortcut for `self.header(header::Subject(subject.into()))`.
-    pub fn subject<S: Into<String>>(self, subject: S) -> Self {
-        let s: String = subject.into();
-        self.header(header::Subject::from(s))
-    }
-
-    /// Set `MIME-Version` header to 1.0
-    ///
-    /// Shortcut for `self.header(header::MIME_VERSION_1_0)`.
-    ///
-    /// Not exposed as it is set by body methods
-    fn mime_1_0(self) -> Self {
-        self.header(header::MIME_VERSION_1_0)
-    }
-
-    /// Set `Sender` header. Should be used when providing several `From` mailboxes.
-    ///
-    /// Defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.2).
-    ///
-    /// Shortcut for `self.header(header::Sender(mbox))`.
-    pub fn sender(self, mbox: Mailbox) -> Self {
-        self.header(header::Sender::from(mbox))
-    }
-
-    /// Set or add mailbox to `From` header
-    ///
-    /// Defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.2).
-    ///
-    /// Shortcut for `self.mailbox(header::From(mbox))`.
-    pub fn from(self, mbox: Mailbox) -> Self {
-        self.mailbox(header::From::from(Mailboxes::from(mbox)))
-    }
-
     /// Set or add mailbox to `ReplyTo` header
     ///
     /// Defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.2).
@@ -354,6 +338,14 @@ impl MessageBuilder {
         self.header(header::References::from(id))
     }
 
+    /// Set `Subject` header to message
+    ///
+    /// Shortcut for `self.header(header::Subject(subject.into()))`.
+    pub fn subject<S: Into<String>>(self, subject: S) -> Self {
+        let s: String = subject.into();
+        self.header(header::Subject::from(s))
+    }
+
     /// Set [Message-ID
     /// header](https://tools.ietf.org/html/rfc5322#section-3.6.4)
     ///
@@ -369,9 +361,9 @@ impl MessageBuilder {
                 let hostname = hostname::get()
                     .map_err(|_| ())
                     .and_then(|s| s.into_string().map_err(|_| ()))
-                    .unwrap_or_else(|_| DEFAULT_MESSAGE_ID_DOMAIN.to_string());
+                    .unwrap_or_else(|_| DEFAULT_MESSAGE_ID_DOMAIN.to_owned());
                 #[cfg(not(feature = "hostname"))]
-                let hostname = DEFAULT_MESSAGE_ID_DOMAIN.to_string();
+                let hostname = DEFAULT_MESSAGE_ID_DOMAIN.to_owned();
 
                 self.header(header::MessageId::from(
                     // https://tools.ietf.org/html/rfc5322#section-3.6.4
@@ -382,17 +374,48 @@ impl MessageBuilder {
     }
 
     /// Set [User-Agent
-    /// header](https://tools.ietf.org/html/draft-melnikov-email-user-agent-004)
+    /// header](https://tools.ietf.org/html/draft-melnikov-email-user-agent-00)
     pub fn user_agent(self, id: String) -> Self {
         self.header(header::UserAgent::from(id))
     }
 
+    /// Set custom header to message
+    pub fn header<H: Header>(mut self, header: H) -> Self {
+        self.headers.set(header);
+        self
+    }
+
+    /// Add mailbox to header
+    pub fn mailbox<H: Header + MailboxesHeader>(self, header: H) -> Self {
+        match self.headers.get::<H>() {
+            Some(mut header_) => {
+                header_.join_mailboxes(header);
+                self.header(header_)
+            }
+            None => self.header(header),
+        }
+    }
+
     /// Force specific envelope (by default it is derived from headers)
     pub fn envelope(mut self, envelope: Envelope) -> Self {
         self.envelope = Some(envelope);
         self
     }
 
+    /// Keep the `Bcc` header
+    ///
+    /// By default, the `Bcc` header is removed from the email after
+    /// using it to generate the message envelope. In some cases though,
+    /// like when saving the email as an `.eml`, or sending through
+    /// some transports (like the Gmail API) that don't take a separate
+    /// envelope value, it becomes necessary to keep the `Bcc` header.
+    ///
+    /// Calling this method overrides the default behavior.
+    pub fn keep_bcc(mut self) -> Self {
+        self.drop_bcc = false;
+        self
+    }
+
     // TODO: High-level methods for attachments and embedded files
 
     /// Create message from body
@@ -401,7 +424,7 @@ impl MessageBuilder {
         // https://tools.ietf.org/html/rfc5322#section-3.6
 
         // Insert Date if missing
-        let res = if self.headers.get::<header::Date>().is_none() {
+        let mut res = if self.headers.get::<header::Date>().is_none() {
             self.date_now()
         } else {
             self
@@ -424,6 +447,12 @@ impl MessageBuilder {
             Some(e) => e,
             None => Envelope::try_from(&res.headers)?,
         };
+
+        if res.drop_bcc {
+            // Remove `Bcc` headers now the envelope is set
+            res.headers.remove::<header::Bcc>();
+        }
+
         Ok(Message {
             headers: res.headers,
             body,
@@ -441,7 +470,7 @@ impl MessageBuilder {
         let body = body.into_body(maybe_encoding);
 
         self.headers.set(body.encoding());
-        self.build(MessageBody::Raw(body.into_vec()))
+        self.build(MessageBody::Raw(body.into_inner()))
     }
 
     /// Create message using mime body ([`MultiPart`][self::MultiPart])
@@ -453,6 +482,15 @@ impl MessageBuilder {
     pub fn singlepart(self, part: SinglePart) -> Result<Message, EmailError> {
         self.mime_1_0().build(MessageBody::Mime(Part::Single(part)))
     }
+
+    /// Set `MIME-Version` header to 1.0
+    ///
+    /// Shortcut for `self.header(header::MIME_VERSION_1_0)`.
+    ///
+    /// Not exposed as it is set by body methods
+    fn mime_1_0(self) -> Self {
+        self.header(header::MIME_VERSION_1_0)
+    }
 }
 
 /// Email message which can be formatted
@@ -467,7 +505,7 @@ pub struct Message {
 #[derive(Clone, Debug)]
 enum MessageBody {
     Mime(Part),
-    Raw(Vec<u8>),
+    Raw(Arc<[u8]>),
 }
 
 impl Message {
@@ -481,6 +519,11 @@ impl Message {
         &self.headers
     }
 
+    /// Get a mutable reference to the headers
+    pub fn headers_mut(&mut self) -> &mut Headers {
+        &mut self.headers
+    }
+
     /// Get `Message` envelope
     pub fn envelope(&self) -> &Envelope {
         &self.envelope
@@ -488,22 +531,89 @@ impl Message {
 
     /// Get message content formatted for SMTP
     pub fn formatted(&self) -> Vec<u8> {
+        self.format_to_vec()
+    }
+
+    #[cfg(feature = "dkim")]
+    /// Format body for signing
+    pub(crate) fn body_raw(&self) -> Vec<u8> {
         let mut out = Vec::new();
-        self.format(&mut out);
+        match &self.body {
+            MessageBody::Mime(p) => p.format_body(&mut out),
+            MessageBody::Raw(r) => out.extend_from_slice(r),
+        };
+        out.extend_from_slice(b"\r\n");
         out
     }
+
+    /// Sign the message using Dkim
+    ///
+    /// Example:
+    /// ```rust
+    /// use lettre::{
+    ///     message::dkim::{DkimConfig, DkimSigningAlgorithm, DkimSigningKey},
+    ///     Message,
+    /// };
+    ///
+    /// let mut message = Message::builder()
+    ///     .from("Alice <alice@example.org>".parse().unwrap())
+    ///     .reply_to("Bob <bob@example.org>".parse().unwrap())
+    ///     .to("Carla <carla@example.net>".parse().unwrap())
+    ///     .subject("Hello")
+    ///     .body("Hi there, it's a test email, with utf-8 chars ë!\n\n\n".to_owned())
+    ///     .unwrap();
+    /// let key = "-----BEGIN RSA PRIVATE KEY-----
+    /// MIIEowIBAAKCAQEAt2gawjoybf0mAz0mSX0cq1ah5F9cPazZdCwLnFBhRufxaZB8
+    /// NLTdc9xfPIOK8l/xGrN7Nd63J4cTATqZukumczkA46O8YKHwa53pNT6NYwCNtDUL
+    /// eBu+7xUW18GmDzkIFkxGO2R5kkTeWPlKvKpEiicIMfl0OmyW/fI3AbtM7e/gmqQ4
+    /// kEYIO0mTjPT+jTgWE4JIi5KUTHudUBtfMKcSFyM2HkUOExl1c9+A4epjRFQwEXMA
+    /// hM5GrqZoOdUm4fIpvGpLIGIxFgHPpZYbyq6yJZzH3+5aKyCHrsHawPuPiCD45zsU
+    /// re31zCE6b6k1sDiiBR4CaRHnbL7hxFp0aNLOVQIDAQABAoIBAGMK3gBrKxaIcUGo
+    /// gQeIf7XrJ6vK72YC9L8uleqI4a9Hy++E7f4MedZ6eBeWta8jrnEL4Yp6xg+beuDc
+    /// A24+Mhng+6Dyp+TLLqj+8pQlPnbrMprRVms7GIXFrrs+wO1RkBNyhy7FmH0roaMM
+    /// pJZzoGW2pE9QdbqjL3rdlWTi/60xRX9eZ42nNxYnbc+RK03SBd46c3UBha6Y9iQX
+    /// 562yWilDnB5WCX2tBoSN39bEhJvuZDzMwOuGw68Q96Hdz82Iz1xVBnRhH+uNStjR
+    /// VnAssSHVxPSpwWrm3sHlhjBHWPnNIaOKIKl1lbL+qWfVQCj/6a5DquC+vYAeYR6L
+    /// 3mA0z0ECgYEA5YkNYcILSXyE0hZ8eA/t58h8eWvYI5iqt3nT4fznCoYJJ74Vukeg
+    /// 6BTlq/CsanwT1lDtvDKrOaJbA7DPTES/bqT0HoeIdOvAw9w/AZI5DAqYp61i6RMK
+    /// xfAQL/Ik5MDFN8gEMLLXRVMe/aR27f6JFZpShJOK/KCzHqikKfYVJ+UCgYEAzI2F
+    /// ZlTyittWSyUSl5UKyfSnFOx2+6vNy+lu5DeMJu8Wh9rqBk388Bxq98CfkCseWESN
+    /// pTCGdYltz9DvVNBdBLwSMdLuYJAI6U+Zd70MWyuNdHFPyWVHUNqMUBvbUtj2w74q
+    /// Hzu0GI0OrRjdX6C63S17PggmT/N2R9X7P4STxbECgYA+AZAD4I98Ao8+0aQ+Ks9x
+    /// 1c8KXf+9XfiAKAD9A3zGcv72JXtpHwBwsXR5xkJNYcdaFfKi7G0k3J8JmDHnwIqW
+    /// MSlhNeu+6hDg2BaNLhsLDbG/Wi9mFybJ4df9m8Qrp4efUgEPxsAwkgvFKTCXijMu
+    /// CspP1iutoxvAJH50d22voQKBgDIsSFtIXNGYaTs3Va8enK3at5zXP3wNsQXiNRP/
+    /// V/44yNL77EktmewfXFF2yuym1uOZtRCerWxpEClYO0wXa6l8pA3aiiPfUIBByQfo
+    /// s/4s2Z6FKKfikrKPWLlRi+NvWl+65kQQ9eTLvJzSq4IIP61+uWsGvrb/pbSLFPyI
+    /// fWKRAoGBALFCStBXvdMptjq4APUzAdJ0vytZzXkOZHxgmc+R0fQn22OiW0huW6iX
+    /// JcaBbL6ZSBIMA3AdaIjtvNRiomueHqh0GspTgOeCE2585TSFnw6vEOJ8RlR4A0Mw
+    /// I45fbR4l+3D/30WMfZlM6bzZbwPXEnr2s1mirmuQpjumY9wLhK25
+    /// -----END RSA PRIVATE KEY-----";
+    /// let signing_key = DkimSigningKey::new(key, DkimSigningAlgorithm::Rsa).unwrap();
+    /// message.sign(&DkimConfig::default_config(
+    ///     "dkimtest".to_owned(),
+    ///     "example.org".to_owned(),
+    ///     signing_key,
+    /// ));
+    /// println!(
+    ///     "message: {}",
+    ///     std::str::from_utf8(&message.formatted()).unwrap()
+    /// );
+    /// ```
+    #[cfg(feature = "dkim")]
+    pub fn sign(&mut self, dkim_config: &DkimConfig) {
+        dkim_sign(self, dkim_config);
+    }
 }
 
 impl EmailFormat for Message {
-    fn format(&self, out: &mut Vec<u8>) {
-        write!(out, "{}", self.headers)
-            .expect("A Write implementation panicked while formatting headers");
+    fn format<'a>(&'a self, out: &mut impl Extend<Cow<'a, [u8]>>) {
+        self.headers.format(out);
 
         match &self.body {
             MessageBody::Mime(p) => p.format(out),
             MessageBody::Raw(r) => {
-                out.extend_from_slice(b"\r\n");
-                out.extend_from_slice(&r)
+                out.extend([Cow::Borrowed("\r\n".as_bytes()), Cow::Borrowed(r)]);
             }
         }
     }
@@ -525,6 +635,8 @@ fn make_message_id() -> String {
 mod test {
     use std::time::{Duration, SystemTime};
 
+    use pretty_assertions::assert_eq;
+
     use super::{header, mailbox::Mailbox, make_message_id, Message, MultiPart, SinglePart};
 
     #[test]
@@ -535,7 +647,7 @@ mod test {
     }
 
     #[test]
-    fn email_miminal_message() {
+    fn email_minimal_message() {
         assert!(Message::builder()
             .from("NoBody <nobody@domain.tld>".parse().unwrap())
             .to("NoBody <nobody@domain.tld>".parse().unwrap())
@@ -553,12 +665,13 @@ mod test {
     }
 
     #[test]
-    fn email_message() {
+    fn email_message_no_bcc() {
         // Tue, 15 Nov 1994 08:12:31 GMT
         let date = SystemTime::UNIX_EPOCH + Duration::from_secs(784887151);
 
         let email = Message::builder()
             .date(date)
+            .bcc("hidden@example.com".parse().unwrap())
             .header(header::From(
                 vec![Mailbox::new(
                     Some("Каи".into()),
@@ -576,9 +689,47 @@ mod test {
         assert_eq!(
             String::from_utf8(email.formatted()).unwrap(),
             concat!(
-                "Date: Tue, 15 Nov 1994 08:12:31 -0000\r\n",
+                "Date: Tue, 15 Nov 1994 08:12:31 +0000\r\n",
                 "From: =?utf-8?b?0JrQsNC4?= <kayo@example.com>\r\n",
-                "To: Pony O.P. <pony@domain.tld>\r\n",
+                "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_message_keep_bcc() {
+        // Tue, 15 Nov 1994 08:12:31 GMT
+        let date = SystemTime::UNIX_EPOCH + Duration::from_secs(784887151);
+
+        let email = Message::builder()
+            .date(date)
+            .bcc("hidden@example.com".parse().unwrap())
+            .keep_bcc()
+            .header(header::From(
+                vec![Mailbox::new(
+                    Some("Каи".into()),
+                    "kayo@example.com".parse().unwrap(),
+                )]
+                .into(),
+            ))
+            .header(header::To(
+                vec!["Pony O.P. <pony@domain.tld>".parse().unwrap()].into(),
+            ))
+            .header(header::Subject::from(String::from("яңа ел белән!")))
+            .body(String::from("Happy new year!"))
+            .unwrap();
+
+        assert_eq!(
+            String::from_utf8(email.formatted()).unwrap(),
+            concat!(
+                "Date: Tue, 15 Nov 1994 08:12:31 +0000\r\n",
+                "Bcc: hidden@example.com\r\n",
+                "From: =?utf-8?b?0JrQsNC4?= <kayo@example.com>\r\n",
+                "To: \"Pony O.P.\" <pony@domain.tld>\r\n",
                 "Subject: =?utf-8?b?0Y/So9CwINC10Lsg0LHQtdC705nQvSE=?=\r\n",
                 "Content-Transfer-Encoding: 7bit\r\n",
                 "\r\n",

src/transport/file/error.rs

@@ -1,8 +1,9 @@
 //! Error and result type for file transport
 
-use crate::BoxError;
 use std::{error::Error as StdError, fmt};
 
+use crate::BoxError;
+
 /// The Errors that may occur when sending an email over SMTP
 pub struct Error {
     inner: Box<Inner>,
@@ -53,7 +54,7 @@ impl fmt::Debug for Error {
 
         builder.field("kind", &self.inner.kind);
 
-        if let Some(ref source) = self.inner.source {
+        if let Some(source) = &self.inner.source {
             builder.field("source", source);
         }
 
@@ -69,8 +70,8 @@ impl fmt::Display for Error {
             Kind::Envelope => f.write_str("internal client error")?,
         };
 
-        if let Some(ref e) = self.inner.source {
-            write!(f, ": {}", e)?;
+        if let Some(e) = &self.inner.source {
+            write!(f, ": {e}")?;
         }
 
         Ok(())

src/transport/file/mod.rs

@@ -9,9 +9,10 @@
 //! #
 //! # #[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::{FileTransport, Message, Transport};
+//!
 //! // Write to the local temp directory
 //! let sender = FileTransport::new(temp_dir());
 //! let email = Message::builder()
@@ -41,9 +42,10 @@
 //! #
 //! # #[cfg(all(feature = "file-transport-envelope", feature = "builder"))]
 //! # fn main() -> Result<(), Box<dyn Error>> {
-//! use lettre::{FileTransport, Message, Transport};
 //! use std::env::temp_dir;
 //!
+//! use lettre::{FileTransport, Message, Transport};
+//!
 //! // Write to the local temp directory
 //! let sender = FileTransport::with_envelope(temp_dir());
 //! let email = Message::builder()
@@ -70,7 +72,8 @@
 //! # #[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};
+//!
+//! use lettre::{AsyncFileTransport, AsyncTransport, Message, Tokio1Executor};
 //!
 //! // Write to the local temp directory
 //! let sender = AsyncFileTransport::<Tokio1Executor>::new(temp_dir());
@@ -95,7 +98,8 @@
 //! # #[cfg(all(feature = "async-std1", feature = "file-transport", feature = "builder"))]
 //! # async fn run() -> Result<(), Box<dyn Error>> {
 //! use std::env::temp_dir;
-//! use lettre::{AsyncTransport, AsyncStd1Executor, Message, AsyncFileTransport};
+//!
+//! use lettre::{AsyncFileTransport, AsyncStd1Executor, AsyncTransport, Message};
 //!
 //! // Write to the local temp directory
 //! let sender = AsyncFileTransport::<AsyncStd1Executor>::new(temp_dir());
@@ -132,26 +136,28 @@
 //! {"forward_path":["hei@domain.tld"],"reverse_path":"nobody@domain.tld"}
 //! ```
 
-pub use self::error::Error;
-use crate::{address::Envelope, Transport};
-#[cfg(any(feature = "async-std1", feature = "tokio1"))]
-use crate::{AsyncTransport, Executor};
-#[cfg(any(feature = "async-std1", feature = "tokio1"))]
-use async_trait::async_trait;
 #[cfg(any(feature = "async-std1", feature = "tokio1"))]
 use std::marker::PhantomData;
 use std::{
     path::{Path, PathBuf},
     str,
 };
+
+#[cfg(any(feature = "async-std1", feature = "tokio1"))]
+use async_trait::async_trait;
 use uuid::Uuid;
 
+pub use self::error::Error;
+use crate::{address::Envelope, Transport};
+#[cfg(any(feature = "async-std1", feature = "tokio1"))]
+use crate::{AsyncTransport, Executor};
+
 mod error;
 
 type Id = String;
 
 /// Writes the content and the envelope information to a file
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(docsrs, doc(cfg(feature = "file-transport")))]
 pub struct FileTransport {
@@ -161,7 +167,7 @@ pub struct FileTransport {
 }
 
 /// Asynchronously writes the content and the envelope information to a file
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(docsrs, doc(cfg(any(feature = "tokio1", feature = "async-std1"))))]
 #[cfg(any(feature = "async-std1", feature = "tokio1"))]
@@ -202,18 +208,18 @@ impl FileTransport {
     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_file = self.path.join(format!("{email_id}.eml"));
         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 json_file = self.path.join(format!("{email_id}.json"));
+        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))
+        self.path.join(format!("{email_id}.{extension}"))
     }
 }
 
@@ -249,10 +255,10 @@ where
     /// 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_file = self.inner.path.join(format!("{email_id}.eml"));
         let eml = E::fs_read(&eml_file).await.map_err(error::io)?;
 
-        let json_file = self.inner.path.join(format!("{}.json", email_id));
+        let json_file = self.inner.path.join(format!("{email_id}.json"));
         let json = E::fs_read(&json_file).await.map_err(error::io)?;
         let envelope = serde_json::from_slice(&json).map_err(error::envelope)?;
 
@@ -270,6 +276,8 @@ impl Transport for FileTransport {
         let email_id = Uuid::new_v4();
 
         let file = self.path(&email_id, "eml");
+        #[cfg(feature = "tracing")]
+        tracing::debug!(?file, "writing email to");
         fs::write(file, email).map_err(error::io)?;
 
         #[cfg(feature = "file-transport-envelope")]
@@ -300,6 +308,8 @@ where
         let email_id = Uuid::new_v4();
 
         let file = self.inner.path(&email_id, "eml");
+        #[cfg(feature = "tracing")]
+        tracing::debug!(?file, "writing email to");
         E::fs_write(&file, email).await.map_err(error::io)?;
 
         #[cfg(feature = "file-transport-envelope")]

src/transport/mod.rs

@@ -12,7 +12,7 @@
 //!
 //! * a service from your Cloud or hosting provider
 //! * an email server ([MTA] for Mail Transfer Agent, like Postfix or Exchange), running either
-//! locally on your servers or accessible over the network
+//!   locally on your servers or accessible over the network
 //! * a dedicated external service, like Mailchimp, Mailgun, etc.
 //!
 //! In most cases, the best option is to:
@@ -32,7 +32,7 @@
 //! | [`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                  |
+//! | [`stub`]     | Debug    | [`StubTransport`]     | [`AsyncStubTransport`]     | Drops the email - Useful for debugging                  |
 //!
 //! ## Building an email
 //!
@@ -56,8 +56,7 @@
 //! #
 //! # #[cfg(all(feature = "builder", feature = "smtp-transport"))]
 //! # fn main() -> Result<(), Box<dyn Error>> {
-//! use lettre::transport::smtp::authentication::Credentials;
-//! use lettre::{Message, SmtpTransport, Transport};
+//! use lettre::{transport::smtp::authentication::Credentials, Message, SmtpTransport, Transport};
 //!
 //! let email = Message::builder()
 //!     .from("NoBody <nobody@domain.tld>".parse()?)
@@ -66,7 +65,7 @@
 //!     .subject("Happy new year")
 //!     .body(String::from("Be happy!"))?;
 //!
-//! let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
+//! let creds = Credentials::new("smtp_username".to_owned(), "smtp_password".to_owned());
 //!
 //! // Open a remote connection to the SMTP relay server
 //! let mailer = SmtpTransport::relay("smtp.gmail.com")?
@@ -76,7 +75,7 @@
 //! // Send the email
 //! match mailer.send(&email) {
 //!     Ok(_) => println!("Email sent successfully!"),
-//!     Err(e) => panic!("Could not send email: {:?}", e),
+//!     Err(e) => panic!("Could not send email: {e:?}"),
 //! }
 //! # Ok(())
 //! # }
@@ -98,6 +97,7 @@
 //! [`FileTransport`]: crate::FileTransport
 //! [`AsyncFileTransport`]: crate::AsyncFileTransport
 //! [`StubTransport`]: crate::transport::stub::StubTransport
+//! [`AsyncStubTransport`]: crate::transport::stub::AsyncStubTransport
 
 #[cfg(any(feature = "async-std1", feature = "tokio1"))]
 use async_trait::async_trait;
@@ -128,6 +128,9 @@ pub trait Transport {
     #[cfg(feature = "builder")]
     #[cfg_attr(docsrs, doc(cfg(feature = "builder")))]
     fn send(&self, message: &Message) -> Result<Self::Ok, Self::Error> {
+        #[cfg(feature = "tracing")]
+        tracing::trace!("starting to send an email");
+
         let raw = message.formatted();
         self.send_raw(message.envelope(), &raw)
     }
@@ -150,9 +153,12 @@ pub trait AsyncTransport {
     #[cfg_attr(docsrs, doc(cfg(feature = "builder")))]
     // TODO take &Message
     async fn send(&self, message: Message) -> Result<Self::Ok, Self::Error> {
+        #[cfg(feature = "tracing")]
+        tracing::trace!("starting to send an email");
+
         let raw = message.formatted();
         let envelope = message.envelope();
-        self.send_raw(&envelope, &raw).await
+        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,8 +1,9 @@
 //! Error and result type for sendmail transport
 
-use crate::BoxError;
 use std::{error::Error as StdError, fmt};
 
+use crate::BoxError;
+
 /// The Errors that may occur when sending an email over sendmail
 pub struct Error {
     inner: Box<Inner>,
@@ -51,7 +52,7 @@ impl fmt::Debug for Error {
 
         builder.field("kind", &self.inner.kind);
 
-        if let Some(ref source) = self.inner.source {
+        if let Some(source) = &self.inner.source {
             builder.field("source", source);
         }
 
@@ -66,8 +67,8 @@ impl fmt::Display for Error {
             Kind::Client => f.write_str("internal client error")?,
         };
 
-        if let Some(ref e) = self.inner.source {
-            write!(f, ": {}", e)?;
+        if let Some(e) = &self.inner.source {
+            write!(f, ": {e}")?;
         }
 
         Ok(())

src/transport/sendmail/mod.rs

@@ -33,7 +33,9 @@
 //! #
 //! # #[cfg(all(feature = "tokio1", feature = "sendmail-transport", feature = "builder"))]
 //! # async fn run() -> Result<(), Box<dyn Error>> {
-//! use lettre::{Message, AsyncTransport, Tokio1Executor, AsyncSendmailTransport, SendmailTransport};
+//! use lettre::{
+//!     AsyncSendmailTransport, AsyncTransport, Message, SendmailTransport, Tokio1Executor,
+//! };
 //!
 //! let email = Message::builder()
 //!     .from("NoBody <nobody@domain.tld>".parse()?)
@@ -72,16 +74,6 @@
 //! # }
 //! ```
 
-pub use self::error::Error;
-#[cfg(feature = "async-std1")]
-use crate::AsyncStd1Executor;
-#[cfg(feature = "tokio1")]
-use crate::Tokio1Executor;
-use crate::{address::Envelope, Transport};
-#[cfg(any(feature = "async-std1", feature = "tokio1"))]
-use crate::{AsyncTransport, Executor};
-#[cfg(any(feature = "async-std1", feature = "tokio1"))]
-use async_trait::async_trait;
 #[cfg(any(feature = "async-std1", feature = "tokio1"))]
 use std::marker::PhantomData;
 use std::{
@@ -90,9 +82,21 @@ use std::{
     process::{Command, Stdio},
 };
 
+#[cfg(any(feature = "async-std1", feature = "tokio1"))]
+use async_trait::async_trait;
+
+pub use self::error::Error;
+#[cfg(feature = "async-std1")]
+use crate::AsyncStd1Executor;
+#[cfg(feature = "tokio1")]
+use crate::Tokio1Executor;
+use crate::{address::Envelope, Transport};
+#[cfg(any(feature = "async-std1", feature = "tokio1"))]
+use crate::{AsyncTransport, Executor};
+
 mod error;
 
-const DEFAULT_SENDMAIL: &str = "/usr/sbin/sendmail";
+const DEFAULT_SENDMAIL: &str = "sendmail";
 
 /// Sends emails using the `sendmail` command
 #[derive(Debug, Clone)]
@@ -113,7 +117,10 @@ pub struct AsyncSendmailTransport<E: Executor> {
 }
 
 impl SendmailTransport {
-    /// Creates a new transport with the default `/usr/sbin/sendmail` command
+    /// Creates a new transport with the `sendmail` command
+    ///
+    /// Note: This uses the `sendmail` command in the current `PATH`. To use another command,
+    /// use [SendmailTransport::new_with_command].
     pub fn new() -> SendmailTransport {
         SendmailTransport {
             command: DEFAULT_SENDMAIL.into(),
@@ -147,7 +154,10 @@ impl<E> AsyncSendmailTransport<E>
 where
     E: Executor,
 {
-    /// Creates a new transport with the default `/usr/sbin/sendmail` command
+    /// Creates a new transport with the `sendmail` command
+    ///
+    /// Note: This uses the `sendmail` command in the current `PATH`. To use another command,
+    /// use [AsyncSendmailTransport::new_with_command].
     pub fn new() -> Self {
         Self {
             inner: SendmailTransport::new(),
@@ -222,6 +232,9 @@ impl Transport for SendmailTransport {
     type Error = Error;
 
     fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
+        #[cfg(feature = "tracing")]
+        tracing::debug!(command = ?self.command, "sending email with");
+
         // Spawn the sendmail command
         let mut process = self.command(envelope).spawn().map_err(error::client)?;
 
@@ -251,6 +264,9 @@ impl AsyncTransport for AsyncSendmailTransport<AsyncStd1Executor> {
     async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
         use async_std::io::prelude::WriteExt;
 
+        #[cfg(feature = "tracing")]
+        tracing::debug!(command = ?self.inner.command, "sending email with");
+
         let mut command = self.async_std_command(envelope);
 
         // Spawn the sendmail command
@@ -260,7 +276,7 @@ impl AsyncTransport for AsyncSendmailTransport<AsyncStd1Executor> {
             .stdin
             .as_mut()
             .unwrap()
-            .write_all(&email)
+            .write_all(email)
             .await
             .map_err(error::client)?;
         let output = process.output().await.map_err(error::client)?;
@@ -283,6 +299,9 @@ impl AsyncTransport for AsyncSendmailTransport<Tokio1Executor> {
     async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
         use tokio1_crate::io::AsyncWriteExt;
 
+        #[cfg(feature = "tracing")]
+        tracing::debug!(command = ?self.inner.command, "sending email with");
+
         let mut command = self.tokio1_command(envelope);
 
         // Spawn the sendmail command
@@ -292,7 +311,7 @@ impl AsyncTransport for AsyncSendmailTransport<Tokio1Executor> {
             .stdin
             .as_mut()
             .unwrap()
-            .write_all(&email)
+            .write_all(email)
             .await
             .map_err(error::client)?;
         let output = process.wait_with_output().await.map_err(error::client)?;

src/transport/smtp/async_transport.rs

@@ -1,10 +1,17 @@
+#[cfg(feature = "pool")]
+use std::sync::Arc;
 use std::{
     fmt::{self, Debug},
     marker::PhantomData,
+    time::Duration,
 };
 
 use async_trait::async_trait;
 
+#[cfg(feature = "pool")]
+use super::pool::async_impl::Pool;
+#[cfg(feature = "pool")]
+use super::PoolConfig;
 use super::{
     client::AsyncSmtpConnection, ClientId, Credentials, Error, Mechanism, Response, SmtpInfo,
 };
@@ -18,8 +25,10 @@ use crate::{Envelope, Executor};
 
 /// Asynchronously sends emails using the SMTP protocol
 #[cfg_attr(docsrs, doc(cfg(any(feature = "tokio1", feature = "async-std1"))))]
-pub struct AsyncSmtpTransport<E> {
-    // TODO: pool
+pub struct AsyncSmtpTransport<E: Executor> {
+    #[cfg(feature = "pool")]
+    inner: Arc<Pool<E>>,
+    #[cfg(not(feature = "pool"))]
     inner: AsyncSmtpClient<E>,
 }
 
@@ -35,6 +44,7 @@ impl AsyncTransport for AsyncSmtpTransport<Tokio1Executor> {
 
         let result = conn.send(envelope, email).await?;
 
+        #[cfg(not(feature = "pool"))]
         conn.quit().await?;
 
         Ok(result)
@@ -72,7 +82,6 @@ where
     #[cfg(any(
         feature = "tokio1-native-tls",
         feature = "tokio1-rustls-tls",
-        feature = "async-std1-native-tls",
         feature = "async-std1-rustls-tls"
     ))]
     #[cfg_attr(
@@ -93,7 +102,7 @@ where
             .tls(Tls::Wrapper(tls_parameters)))
     }
 
-    /// Simple an secure transport, using STARTTLS to obtain encrypted connections
+    /// Simple and secure transport, using STARTTLS to obtain encrypted connections
     ///
     /// Alternative to [`AsyncSmtpTransport::relay`](#method.relay), for SMTP servers
     /// that don't take SMTPS connections.
@@ -107,7 +116,6 @@ where
     #[cfg(any(
         feature = "tokio1-native-tls",
         feature = "tokio1-rustls-tls",
-        feature = "async-std1-native-tls",
         feature = "async-std1-rustls-tls"
     ))]
     #[cfg_attr(
@@ -141,21 +149,127 @@ where
     ///
     /// * No authentication
     /// * No TLS
+    /// * A 60-seconds timeout for smtp commands
     /// * Port 25
     ///
     /// Consider using [`AsyncSmtpTransport::relay`](#method.relay) or
     /// [`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()
-        };
-        AsyncSmtpTransportBuilder { info: new }
+        AsyncSmtpTransportBuilder::new(server)
+    }
+
+    /// Creates a `AsyncSmtpTransportBuilder` from a connection URL
+    ///
+    /// The protocol, credentials, host and port can be provided in a single URL.
+    /// Use the scheme `smtp` for an unencrypted relay (optionally in combination with the
+    /// `tls` parameter to allow/require STARTTLS) or `smtps` for SMTP over TLS.
+    /// The path section of the url can be used to set an alternative name for
+    /// the HELO / EHLO command.
+    /// For example `smtps://username:password@smtp.example.com/client.example.com:465`
+    /// will set the HELO / EHLO name `client.example.com`.
+    ///
+    /// <table>
+    ///   <thead>
+    ///     <tr>
+    ///       <th>scheme</th>
+    ///       <th>tls parameter</th>
+    ///       <th>example</th>
+    ///       <th>remarks</th>
+    ///     </tr>
+    ///   </thead>
+    ///   <tbody>
+    ///     <tr>
+    ///      <td>smtps</td>
+    ///      <td>-</td>
+    ///      <td>smtps://smtp.example.com</td>
+    ///      <td>SMTP over TLS, recommended method</td>
+    ///     </tr>
+    ///     <tr>
+    ///      <td>smtp</td>
+    ///      <td>required</td>
+    ///      <td>smtp://smtp.example.com?tls=required</td>
+    ///      <td>SMTP with STARTTLS required, when SMTP over TLS is not available</td>
+    ///     </tr>
+    ///     <tr>
+    ///      <td>smtp</td>
+    ///      <td>opportunistic</td>
+    ///      <td>smtp://smtp.example.com?tls=opportunistic</td>
+    ///      <td>
+    ///         SMTP with optionally STARTTLS when supported by the server.
+    ///         Caution: this method is vulnerable to a man-in-the-middle attack.
+    ///         Not recommended for production use.
+    ///       </td>
+    ///     </tr>
+    ///     <tr>
+    ///      <td>smtp</td>
+    ///      <td>-</td>
+    ///      <td>smtp://smtp.example.com</td>
+    ///      <td>Unencrypted SMTP, not recommended for production use.</td>
+    ///     </tr>
+    ///   </tbody>
+    /// </table>
+    ///
+    /// ```rust,no_run
+    /// use lettre::{
+    ///     message::header::ContentType, transport::smtp::authentication::Credentials,
+    ///     AsyncSmtpTransport, AsyncTransport, Message, Tokio1Executor,
+    /// };
+    /// # use tokio1_crate as tokio;
+    ///
+    /// # #[tokio::main]
+    /// # async fn main() -> Result<(), Box<dyn std::error::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")
+    ///     .header(ContentType::TEXT_PLAIN)
+    ///     .body(String::from("Be happy!"))
+    ///     .unwrap();
+    ///
+    /// // Open a remote connection to gmail
+    /// let mailer: AsyncSmtpTransport<Tokio1Executor> =
+    ///     AsyncSmtpTransport::<Tokio1Executor>::from_url(
+    ///         "smtps://username:password@smtp.example.com:465",
+    ///     )
+    ///     .unwrap()
+    ///     .build();
+    ///
+    /// // Send the email
+    /// match mailer.send(email).await {
+    ///     Ok(_) => println!("Email sent successfully!"),
+    ///     Err(e) => panic!("Could not send email: {e:?}"),
+    /// }
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
+    pub fn from_url(connection_url: &str) -> Result<AsyncSmtpTransportBuilder, Error> {
+        super::connection_url::from_connection_url(connection_url)
+    }
+
+    /// Tests the SMTP connection
+    ///
+    /// `test_connection()` tests the connection by using the SMTP NOOP command.
+    /// The connection is closed afterward if a connection pool is not used.
+    pub async fn test_connection(&self) -> Result<bool, Error> {
+        let mut conn = self.inner.connection().await?;
+
+        let is_connected = conn.test_connected().await;
+
+        #[cfg(not(feature = "pool"))]
+        conn.quit().await?;
+
+        Ok(is_connected)
     }
 }
 
-impl<E> Debug for AsyncSmtpTransport<E> {
+impl<E: Executor> 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);
@@ -169,6 +283,9 @@ where
 {
     fn clone(&self) -> Self {
         Self {
+            #[cfg(feature = "pool")]
+            inner: Arc::clone(&self.inner),
+            #[cfg(not(feature = "pool"))]
             inner: self.inner.clone(),
         }
     }
@@ -180,10 +297,26 @@ where
 #[cfg_attr(docsrs, doc(cfg(any(feature = "tokio1", feature = "async-std1"))))]
 pub struct AsyncSmtpTransportBuilder {
     info: SmtpInfo,
+    #[cfg(feature = "pool")]
+    pool_config: PoolConfig,
 }
 
 /// Builder for the SMTP `AsyncSmtpTransport`
 impl AsyncSmtpTransportBuilder {
+    // Create new builder with default parameters
+    pub(crate) fn new<T: Into<String>>(server: T) -> Self {
+        let info = SmtpInfo {
+            server: server.into(),
+            ..Default::default()
+        };
+
+        AsyncSmtpTransportBuilder {
+            info,
+            #[cfg(feature = "pool")]
+            pool_config: PoolConfig::default(),
+        }
+    }
+
     /// Set the name used during EHLO
     pub fn hello_name(mut self, name: ClientId) -> Self {
         self.info.hello_name = name;
@@ -208,11 +341,16 @@ impl AsyncSmtpTransportBuilder {
         self
     }
 
+    /// Set the timeout duration
+    pub fn timeout(mut self, timeout: Option<Duration>) -> Self {
+        self.info.timeout = timeout;
+        self
+    }
+
     /// Set the TLS settings to use
     #[cfg(any(
         feature = "tokio1-native-tls",
         feature = "tokio1-rustls-tls",
-        feature = "async-std1-native-tls",
         feature = "async-std1-rustls-tls"
     ))]
     #[cfg_attr(
@@ -228,6 +366,16 @@ impl AsyncSmtpTransportBuilder {
         self
     }
 
+    /// Use a custom configuration for the connection pool
+    ///
+    /// Defaults can be found at [`PoolConfig`]
+    #[cfg(feature = "pool")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "pool")))]
+    pub fn pool_config(mut self, pool_config: PoolConfig) -> Self {
+        self.pool_config = pool_config;
+        self
+    }
+
     /// Build the transport
     pub fn build<E>(self) -> AsyncSmtpTransport<E>
     where
@@ -237,6 +385,10 @@ impl AsyncSmtpTransportBuilder {
             info: self.info,
             marker_: PhantomData,
         };
+
+        #[cfg(feature = "pool")]
+        let client = Pool::new(self.pool_config, client);
+
         AsyncSmtpTransport { inner: client }
     }
 }
@@ -258,13 +410,14 @@ where
         let mut conn = E::connect(
             &self.info.server,
             self.info.port,
+            self.info.timeout,
             &self.info.hello_name,
             &self.info.tls,
         )
         .await?;
 
         if let Some(credentials) = &self.info.credentials {
-            conn.auth(&self.info.authentication, &credentials).await?;
+            conn.auth(&self.info.authentication, credentials).await?;
         }
         Ok(conn)
     }
@@ -278,6 +431,8 @@ impl<E> Debug for AsyncSmtpClient<E> {
     }
 }
 
+// `clone` is unused when the `pool` feature is on
+#[allow(dead_code)]
 impl<E> AsyncSmtpClient<E>
 where
     E: Executor,

src/transport/smtp/authentication.rs

@@ -1,9 +1,11 @@
 //! Provides limited SASL authentication mechanisms
 
-use crate::transport::smtp::error::{self, Error};
 use std::fmt::{self, Debug, Display, Formatter};
 
+use crate::transport::smtp::error::{self, Error};
+
 /// Accepted authentication mechanisms
+///
 /// Trying LOGIN last as it is deprecated.
 pub const DEFAULT_MECHANISMS: &[Mechanism] = &[Mechanism::Plain, Mechanism::Login];
 
@@ -49,7 +51,7 @@ pub enum Mechanism {
     /// [RFC 4616](https://tools.ietf.org/html/rfc4616)
     Plain,
     /// LOGIN authentication mechanism
-    /// Obsolete but needed for some providers (like office365)
+    /// Obsolete but needed for some providers (like Office 365)
     ///
     /// Defined in [draft-murchison-sasl-login-00](https://www.ietf.org/archive/id/draft-murchison-sasl-login-00.txt).
     Login,
@@ -69,7 +71,7 @@ impl Display for Mechanism {
 }
 
 impl Mechanism {
-    /// Does the mechanism supports initial response
+    /// Does the mechanism support initial response?
     pub fn supports_initial_response(self) -> bool {
         match self {
             Mechanism::Plain | Mechanism::Xoauth2 => true,
@@ -96,12 +98,14 @@ impl Mechanism {
                 let decoded_challenge = challenge
                     .ok_or_else(|| error::client("This mechanism does expect a challenge"))?;
 
-                if vec!["User Name", "Username:", "Username"].contains(&decoded_challenge) {
-                    return Ok(credentials.authentication_identity.to_string());
+                if ["User Name", "Username:", "Username", "User Name\0"]
+                    .contains(&decoded_challenge)
+                {
+                    return Ok(credentials.authentication_identity.clone());
                 }
 
-                if vec!["Password", "Password:"].contains(&decoded_challenge) {
-                    return Ok(credentials.secret.to_string());
+                if ["Password", "Password:", "Password\0"].contains(&decoded_challenge) {
+                    return Ok(credentials.secret.clone());
                 }
 
                 Err(error::client("Unrecognized challenge"))
@@ -125,7 +129,7 @@ mod test {
     fn test_plain() {
         let mechanism = Mechanism::Plain;
 
-        let credentials = Credentials::new("username".to_string(), "password".to_string());
+        let credentials = Credentials::new("username".to_owned(), "password".to_owned());
 
         assert_eq!(
             mechanism.response(&credentials, None).unwrap(),
@@ -138,7 +142,7 @@ mod test {
     fn test_login() {
         let mechanism = Mechanism::Login;
 
-        let credentials = Credentials::new("alice".to_string(), "wonderland".to_string());
+        let credentials = Credentials::new("alice".to_owned(), "wonderland".to_owned());
 
         assert_eq!(
             mechanism.response(&credentials, Some("Username")).unwrap(),
@@ -156,8 +160,8 @@ mod test {
         let mechanism = Mechanism::Xoauth2;
 
         let credentials = Credentials::new(
-            "username".to_string(),
-            "vF9dft4qmTc2Nvb3RlckBhdHRhdmlzdGEuY29tCg==".to_string(),
+            "username".to_owned(),
+            "vF9dft4qmTc2Nvb3RlckBhdHRhdmlzdGEuY29tCg==".to_owned(),
         );
 
         assert_eq!(
@@ -170,7 +174,7 @@ mod test {
     #[test]
     fn test_from_user_pass_for_credentials() {
         assert_eq!(
-            Credentials::new("alice".to_string(), "wonderland".to_string()),
+            Credentials::new("alice".to_owned(), "wonderland".to_owned()),
             Credentials::from(("alice", "wonderland"))
         );
     }

src/transport/smtp/client/async_connection.rs

@@ -1,8 +1,16 @@
+use std::{fmt::Display, net::IpAddr, time::Duration};
+
+use futures_util::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+
+#[cfg(feature = "tokio1")]
+use super::async_net::AsyncTokioStream;
+#[cfg(feature = "tracing")]
+use super::escape_crlf;
 use super::{AsyncNetworkStream, ClientCodec, TlsParameters};
 use crate::{
     transport::smtp::{
         authentication::{Credentials, Mechanism},
-        commands::*,
+        commands::{Auth, Data, Ehlo, Mail, Noop, Quit, Rcpt, Starttls},
         error,
         error::Error,
         extension::{ClientId, Extension, MailBodyParameter, MailParameter, ServerInfo},
@@ -10,11 +18,6 @@ use crate::{
     },
     Envelope,
 };
-use futures_util::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
-use std::fmt::Display;
-
-#[cfg(feature = "tracing")]
-use super::escape_crlf;
 
 macro_rules! try_smtp (
     ($err: expr, $client: ident) => ({
@@ -40,21 +43,65 @@ pub struct AsyncSmtpConnection {
 }
 
 impl AsyncSmtpConnection {
+    /// Get information about the server
     pub fn server_info(&self) -> &ServerInfo {
         &self.server_info
     }
 
-    /// Connects to the configured server
+    /// Connects with existing async stream
     ///
     /// Sends EHLO and parses server information
     #[cfg(feature = "tokio1")]
-    pub async fn connect_tokio1(
-        hostname: &str,
-        port: u16,
+    pub async fn connect_with_transport(
+        stream: Box<dyn AsyncTokioStream>,
+        hello_name: &ClientId,
+    ) -> Result<AsyncSmtpConnection, Error> {
+        let stream = AsyncNetworkStream::use_existing_tokio1(stream);
+        Self::connect_impl(stream, hello_name).await
+    }
+
+    /// Connects to the configured server
+    ///
+    /// If `tls_parameters` is `Some`, then the connection will use Implicit TLS (sometimes
+    /// referred to as `SMTPS`). See also [`AsyncSmtpConnection::starttls`].
+    ///
+    /// If `local_address` is `Some`, then the address provided shall be used to bind the
+    /// connection to a specific local address using [`tokio1_crate::net::TcpSocket::bind`].
+    ///
+    /// Sends EHLO and parses server information
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// # use std::time::Duration;
+    /// # use lettre::transport::smtp::{client::{AsyncSmtpConnection, TlsParameters}, extension::ClientId};
+    /// # use tokio1_crate::{self as tokio, net::ToSocketAddrs as _};
+    /// #
+    /// # #[tokio::main]
+    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    /// let connection = AsyncSmtpConnection::connect_tokio1(
+    ///     ("example.com", 465),
+    ///     Some(Duration::from_secs(60)),
+    ///     &ClientId::default(),
+    ///     Some(TlsParameters::new("example.com".to_owned())?),
+    ///     None,
+    /// )
+    /// .await
+    /// .unwrap();
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[cfg(feature = "tokio1")]
+    pub async fn connect_tokio1<T: tokio1_crate::net::ToSocketAddrs>(
+        server: T,
+        timeout: Option<Duration>,
         hello_name: &ClientId,
         tls_parameters: Option<TlsParameters>,
+        local_address: Option<IpAddr>,
     ) -> Result<AsyncSmtpConnection, Error> {
-        let stream = AsyncNetworkStream::connect_tokio1(hostname, port, tls_parameters).await?;
+        let stream =
+            AsyncNetworkStream::connect_tokio1(server, timeout, tls_parameters, local_address)
+                .await?;
         Self::connect_impl(stream, hello_name).await
     }
 
@@ -62,13 +109,13 @@ impl AsyncSmtpConnection {
     ///
     /// Sends EHLO and parses server information
     #[cfg(feature = "async-std1")]
-    pub async fn connect_asyncstd1(
-        hostname: &str,
-        port: u16,
+    pub async fn connect_asyncstd1<T: async_std::net::ToSocketAddrs>(
+        server: T,
+        timeout: Option<Duration>,
         hello_name: &ClientId,
         tls_parameters: Option<TlsParameters>,
     ) -> Result<AsyncSmtpConnection, Error> {
-        let stream = AsyncNetworkStream::connect_asyncstd1(hostname, port, tls_parameters).await?;
+        let stream = AsyncNetworkStream::connect_asyncstd1(server, timeout, tls_parameters).await?;
         Self::connect_impl(stream, hello_name).await
     }
 
@@ -113,7 +160,7 @@ impl AsyncSmtpConnection {
             mail_options.push(MailParameter::SmtpUtfEight);
         }
 
-        // Check for non-ascii content in message
+        // Check for non-ascii content in the message
         if !email.is_ascii() {
             if !self.server_info().supports_feature(Extension::EightBitMime) {
                 return Err(error::client(
@@ -153,6 +200,12 @@ impl AsyncSmtpConnection {
         !self.is_encrypted() && self.server_info.supports_feature(Extension::StartTls)
     }
 
+    /// Upgrade the connection using `STARTTLS`.
+    ///
+    /// As described in [rfc3207]. Note that this mechanism has been deprecated in [rfc8314].
+    ///
+    /// [rfc3207]: https://www.rfc-editor.org/rfc/rfc3207
+    /// [rfc8314]: https://www.rfc-editor.org/rfc/rfc8314
     #[allow(unused_variables)]
     pub async fn starttls(
         &mut self,
@@ -161,10 +214,7 @@ impl AsyncSmtpConnection {
     ) -> Result<(), Error> {
         if self.server_info.supports_feature(Extension::StartTls) {
             try_smtp!(self.command(Starttls).await, self);
-            try_smtp!(
-                self.stream.get_mut().upgrade_tls(tls_parameters).await,
-                self
-            );
+            self.stream.get_mut().upgrade_tls(tls_parameters).await?;
             #[cfg(feature = "tracing")]
             tracing::debug!("connection encrypted");
             // Send EHLO again
@@ -192,6 +242,7 @@ impl AsyncSmtpConnection {
             self.panic = true;
             let _ = self.command(Quit).await;
         }
+        let _ = self.stream.close().await;
     }
 
     /// Sets the underlying stream
@@ -209,7 +260,7 @@ impl AsyncSmtpConnection {
         self.command(Noop).await.is_ok()
     }
 
-    /// Sends an AUTH command with the given mechanism, and handles challenge if needed
+    /// Sends an AUTH command with the given mechanism, and handles the challenge if needed
     pub async fn auth(
         &mut self,
         mechanisms: &[Mechanism],
@@ -298,7 +349,10 @@ impl AsyncSmtpConnection {
                     return if response.is_positive() {
                         Ok(response)
                     } else {
-                        Err(error::code(response.code))
+                        Err(error::code(
+                            response.code(),
+                            Some(response.message().collect()),
+                        ))
                     }
                 }
                 Err(nom::Err::Failure(e)) => {
@@ -313,4 +367,16 @@ impl AsyncSmtpConnection {
 
         Err(error::response("incomplete response"))
     }
+
+    /// The X509 certificate of the server (DER encoded)
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    pub fn peer_certificate(&self) -> Result<Vec<u8>, Error> {
+        self.stream.get_ref().peer_certificate()
+    }
+
+    /// All the X509 certificates of the chain (DER encoded)
+    #[cfg(any(feature = "rustls-tls", feature = "boring-tls"))]
+    pub fn certificate_chain(&self) -> Result<Vec<Vec<u8>>, Error> {
+        self.stream.get_ref().certificate_chain()
+    }
 }

src/transport/smtp/client/async_net.rs

@@ -1,69 +1,88 @@
 use std::{
-    mem,
-    net::SocketAddr,
+    fmt, io, mem,
+    net::{IpAddr, SocketAddr},
     pin::Pin,
     task::{Context, Poll},
+    time::Duration,
 };
 
+#[cfg(feature = "async-std1")]
+use async_std::net::{TcpStream as AsyncStd1TcpStream, ToSocketAddrs as AsyncStd1ToSocketAddrs};
 use futures_io::{
     AsyncRead as FuturesAsyncRead, AsyncWrite as FuturesAsyncWrite, Error as IoError, ErrorKind,
     Result as IoResult,
 };
+#[cfg(feature = "async-std1-rustls-tls")]
+use futures_rustls::client::TlsStream as AsyncStd1RustlsTlsStream;
+#[cfg(any(feature = "tokio1-rustls-tls", feature = "async-std1-rustls-tls"))]
+use rustls::pki_types::ServerName;
+#[cfg(feature = "tokio1-boring-tls")]
+use tokio1_boring::SslStream as Tokio1SslStream;
 #[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 tokio1_crate::io::{AsyncRead, AsyncWrite, ReadBuf as Tokio1ReadBuf};
 #[cfg(feature = "tokio1")]
-use tokio1_crate::net::TcpStream as Tokio1TcpStream;
-
-#[cfg(feature = "async-std1-native-tls")]
-use async_native_tls::TlsStream as AsyncStd1TlsStream;
+use tokio1_crate::net::{
+    TcpSocket as Tokio1TcpSocket, TcpStream as Tokio1TcpStream,
+    ToSocketAddrs as Tokio1ToSocketAddrs,
+};
 #[cfg(feature = "tokio1-native-tls")]
 use tokio1_native_tls_crate::TlsStream as Tokio1TlsStream;
-
-#[cfg(feature = "async-std1-rustls-tls")]
-use async_rustls::client::TlsStream as AsyncStd1RustlsTlsStream;
 #[cfg(feature = "tokio1-rustls-tls")]
 use tokio1_rustls::client::TlsStream as Tokio1RustlsTlsStream;
 
 #[cfg(any(
     feature = "tokio1-native-tls",
     feature = "tokio1-rustls-tls",
-    feature = "async-std1-native-tls",
+    feature = "tokio1-boring-tls",
     feature = "async-std1-rustls-tls"
 ))]
 use super::InnerTlsParameters;
 use super::TlsParameters;
+#[cfg(feature = "tokio1")]
+use crate::transport::smtp::client::net::resolved_address_filter;
 use crate::transport::smtp::{error, Error};
 
 /// A network stream
+#[derive(Debug)]
 pub struct AsyncNetworkStream {
     inner: InnerAsyncNetworkStream,
 }
 
+#[cfg(feature = "tokio1")]
+pub trait AsyncTokioStream: AsyncRead + AsyncWrite + Send + Sync + Unpin + fmt::Debug {
+    fn peer_addr(&self) -> io::Result<SocketAddr>;
+}
+
+#[cfg(feature = "tokio1")]
+impl AsyncTokioStream for Tokio1TcpStream {
+    fn peer_addr(&self) -> io::Result<SocketAddr> {
+        self.peer_addr()
+    }
+}
+
 /// 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)]
+#[derive(Debug)]
 enum InnerAsyncNetworkStream {
     /// Plain Tokio 1.x TCP stream
     #[cfg(feature = "tokio1")]
-    Tokio1Tcp(Tokio1TcpStream),
+    Tokio1Tcp(Box<dyn AsyncTokioStream>),
     /// Encrypted Tokio 1.x TCP stream
     #[cfg(feature = "tokio1-native-tls")]
-    Tokio1NativeTls(Tokio1TlsStream<Tokio1TcpStream>),
+    Tokio1NativeTls(Tokio1TlsStream<Box<dyn AsyncTokioStream>>),
     /// Encrypted Tokio 1.x TCP stream
     #[cfg(feature = "tokio1-rustls-tls")]
-    Tokio1RustlsTls(Tokio1RustlsTlsStream<Tokio1TcpStream>),
+    Tokio1RustlsTls(Tokio1RustlsTlsStream<Box<dyn AsyncTokioStream>>),
+    /// Encrypted Tokio 1.x TCP stream
+    #[cfg(feature = "tokio1-boring-tls")]
+    Tokio1BoringTls(Tokio1SslStream<Box<dyn AsyncTokioStream>>),
     /// Plain Tokio 1.x TCP stream
     #[cfg(feature = "async-std1")]
     AsyncStd1Tcp(AsyncStd1TcpStream),
     /// Encrypted Tokio 1.x TCP stream
-    #[cfg(feature = "async-std1-native-tls")]
-    AsyncStd1NativeTls(AsyncStd1TlsStream<AsyncStd1TcpStream>),
-    /// Encrypted Tokio 1.x TCP stream
     #[cfg(feature = "async-std1-rustls-tls")]
     AsyncStd1RustlsTls(AsyncStd1RustlsTlsStream<AsyncStd1TcpStream>),
     /// Can't be built
@@ -81,21 +100,21 @@ impl AsyncNetworkStream {
 
     /// Returns peer's address
     pub fn peer_addr(&self) -> IoResult<SocketAddr> {
-        match self.inner {
+        match &self.inner {
             #[cfg(feature = "tokio1")]
-            InnerAsyncNetworkStream::Tokio1Tcp(ref s) => s.peer_addr(),
+            InnerAsyncNetworkStream::Tokio1Tcp(s) => s.peer_addr(),
             #[cfg(feature = "tokio1-native-tls")]
-            InnerAsyncNetworkStream::Tokio1NativeTls(ref s) => {
+            InnerAsyncNetworkStream::Tokio1NativeTls(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(),
+            InnerAsyncNetworkStream::Tokio1RustlsTls(s) => s.get_ref().0.peer_addr(),
+            #[cfg(feature = "tokio1-boring-tls")]
+            InnerAsyncNetworkStream::Tokio1BoringTls(s) => s.get_ref().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(),
+            InnerAsyncNetworkStream::AsyncStd1Tcp(s) => s.peer_addr(),
             #[cfg(feature = "async-std1-rustls-tls")]
-            InnerAsyncNetworkStream::AsyncStd1RustlsTls(ref s) => s.get_ref().0.peer_addr(),
+            InnerAsyncNetworkStream::AsyncStd1RustlsTls(s) => s.get_ref().0.peer_addr(),
             InnerAsyncNetworkStream::None => {
                 debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
                 Err(IoError::new(
@@ -107,16 +126,70 @@ impl AsyncNetworkStream {
     }
 
     #[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)?;
+    pub fn use_existing_tokio1(stream: Box<dyn AsyncTokioStream>) -> AsyncNetworkStream {
+        AsyncNetworkStream::new(InnerAsyncNetworkStream::Tokio1Tcp(stream))
+    }
 
-        let mut stream = AsyncNetworkStream::new(InnerAsyncNetworkStream::Tokio1Tcp(tcp_stream));
+    #[cfg(feature = "tokio1")]
+    pub async fn connect_tokio1<T: Tokio1ToSocketAddrs>(
+        server: T,
+        timeout: Option<Duration>,
+        tls_parameters: Option<TlsParameters>,
+        local_addr: Option<IpAddr>,
+    ) -> Result<AsyncNetworkStream, Error> {
+        async fn try_connect<T: Tokio1ToSocketAddrs>(
+            server: T,
+            timeout: Option<Duration>,
+            local_addr: Option<IpAddr>,
+        ) -> Result<Tokio1TcpStream, Error> {
+            let addrs = tokio1_crate::net::lookup_host(server)
+                .await
+                .map_err(error::connection)?
+                .filter(|resolved_addr| resolved_address_filter(resolved_addr, local_addr));
+
+            let mut last_err = None;
+
+            for addr in addrs {
+                let socket = match addr.ip() {
+                    IpAddr::V4(_) => Tokio1TcpSocket::new_v4(),
+                    IpAddr::V6(_) => Tokio1TcpSocket::new_v6(),
+                }
+                .map_err(error::connection)?;
+                if let Some(local_addr) = local_addr {
+                    socket
+                        .bind(SocketAddr::new(local_addr, 0))
+                        .map_err(error::connection)?;
+                }
+
+                let connect_future = socket.connect(addr);
+                if let Some(timeout) = timeout {
+                    match tokio1_crate::time::timeout(timeout, connect_future).await {
+                        Ok(Ok(stream)) => return Ok(stream),
+                        Ok(Err(err)) => last_err = Some(err),
+                        Err(_) => {
+                            last_err = Some(io::Error::new(
+                                io::ErrorKind::TimedOut,
+                                "connection timed out",
+                            ))
+                        }
+                    }
+                } else {
+                    match connect_future.await {
+                        Ok(stream) => return Ok(stream),
+                        Err(err) => last_err = Some(err),
+                    }
+                }
+            }
+
+            Err(match last_err {
+                Some(last_err) => error::connection(last_err),
+                None => error::connection("could not resolve to any supported address"),
+            })
+        }
+
+        let tcp_stream = try_connect(server, timeout, local_addr).await?;
+        let mut stream =
+            AsyncNetworkStream::new(InnerAsyncNetworkStream::Tokio1Tcp(Box::new(tcp_stream)));
         if let Some(tls_parameters) = tls_parameters {
             stream.upgrade_tls(tls_parameters).await?;
         }
@@ -124,14 +197,48 @@ impl AsyncNetworkStream {
     }
 
     #[cfg(feature = "async-std1")]
-    pub async fn connect_asyncstd1(
-        hostname: &str,
-        port: u16,
+    pub async fn connect_asyncstd1<T: AsyncStd1ToSocketAddrs>(
+        server: T,
+        timeout: Option<Duration>,
         tls_parameters: Option<TlsParameters>,
     ) -> Result<AsyncNetworkStream, Error> {
-        let tcp_stream = AsyncStd1TcpStream::connect((hostname, port))
-            .await
-            .map_err(error::connection)?;
+        // Unfortunately, there doesn't currently seem to be a way to set the local address.
+        // Whilst we can create a AsyncStd1TcpStream from an existing socket, it needs to first have
+        // been connected, which is a blocking operation.
+        async fn try_connect_timeout<T: AsyncStd1ToSocketAddrs>(
+            server: T,
+            timeout: Duration,
+        ) -> Result<AsyncStd1TcpStream, Error> {
+            let addrs = server.to_socket_addrs().await.map_err(error::connection)?;
+
+            let mut last_err = None;
+
+            for addr in addrs {
+                let connect_future = AsyncStd1TcpStream::connect(&addr);
+                match async_std::future::timeout(timeout, connect_future).await {
+                    Ok(Ok(stream)) => return Ok(stream),
+                    Ok(Err(err)) => last_err = Some(err),
+                    Err(_) => {
+                        last_err = Some(io::Error::new(
+                            io::ErrorKind::TimedOut,
+                            "connection timed out",
+                        ))
+                    }
+                }
+            }
+
+            Err(match last_err {
+                Some(last_err) => error::connection(last_err),
+                None => error::connection("could not resolve to any address"),
+            })
+        }
+
+        let tcp_stream = match timeout {
+            Some(t) => try_connect_timeout(server, t).await?,
+            None => AsyncStd1TcpStream::connect(server)
+                .await
+                .map_err(error::connection)?,
+        };
 
         let mut stream = AsyncNetworkStream::new(InnerAsyncNetworkStream::AsyncStd1Tcp(tcp_stream));
         if let Some(tls_parameters) = tls_parameters {
@@ -144,14 +251,22 @@ impl AsyncNetworkStream {
         match &self.inner {
             #[cfg(all(
                 feature = "tokio1",
-                not(any(feature = "tokio1-native-tls", feature = "tokio1-rustls-tls"))
+                not(any(
+                    feature = "tokio1-native-tls",
+                    feature = "tokio1-rustls-tls",
+                    feature = "tokio1-boring-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"))]
+            #[cfg(any(
+                feature = "tokio1-native-tls",
+                feature = "tokio1-rustls-tls",
+                feature = "tokio1-boring-tls"
+            ))]
             InnerAsyncNetworkStream::Tokio1Tcp(_) => {
                 // get owned TcpStream
                 let tcp_stream = mem::replace(&mut self.inner, InnerAsyncNetworkStream::None);
@@ -165,16 +280,13 @@ impl AsyncNetworkStream {
                     .map_err(error::connection)?;
                 Ok(())
             }
-            #[cfg(all(
-                feature = "async-std1",
-                not(any(feature = "async-std1-native-tls", feature = "async-std1-rustls-tls"))
-            ))]
+            #[cfg(all(feature = "async-std1", not(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");
+                panic!("Trying to upgrade an AsyncNetworkStream without having enabled the async-std1-rustls-tls feature");
             }
 
-            #[cfg(any(feature = "async-std1-native-tls", feature = "async-std1-rustls-tls"))]
+            #[cfg(feature = "async-std1-rustls-tls")]
             InnerAsyncNetworkStream::AsyncStd1Tcp(_) => {
                 // get owned TcpStream
                 let tcp_stream = mem::replace(&mut self.inner, InnerAsyncNetworkStream::None);
@@ -193,12 +305,16 @@ impl AsyncNetworkStream {
     }
 
     #[allow(unused_variables)]
-    #[cfg(any(feature = "tokio1-native-tls", feature = "tokio1-rustls-tls"))]
+    #[cfg(any(
+        feature = "tokio1-native-tls",
+        feature = "tokio1-rustls-tls",
+        feature = "tokio1-boring-tls"
+    ))]
     async fn upgrade_tokio1_tls(
-        tcp_stream: Tokio1TcpStream,
-        mut tls_parameters: TlsParameters,
+        tcp_stream: Box<dyn AsyncTokioStream>,
+        tls_parameters: TlsParameters,
     ) -> Result<InnerAsyncNetworkStream, Error> {
-        let domain = mem::take(&mut tls_parameters.domain);
+        let domain = tls_parameters.domain().to_owned();
 
         match tls_parameters.connector {
             #[cfg(feature = "native-tls")]
@@ -225,24 +341,40 @@ impl AsyncNetworkStream {
 
                 #[cfg(feature = "tokio1-rustls-tls")]
                 return {
-                    use tokio1_rustls::{webpki::DNSNameRef, TlsConnector};
+                    use tokio1_rustls::TlsConnector;
 
-                    let domain =
-                        DNSNameRef::try_from_ascii_str(&domain).map_err(error::connection)?;
+                    let domain = ServerName::try_from(domain.as_str())
+                        .map_err(|_| error::connection("domain isn't a valid DNS name"))?;
 
                     let connector = TlsConnector::from(config);
                     let stream = connector
-                        .connect(domain, tcp_stream)
+                        .connect(domain.to_owned(), tcp_stream)
                         .await
                         .map_err(error::connection)?;
                     Ok(InnerAsyncNetworkStream::Tokio1RustlsTls(stream))
                 };
             }
+            #[cfg(feature = "boring-tls")]
+            InnerTlsParameters::BoringTls(connector) => {
+                #[cfg(not(feature = "tokio1-boring-tls"))]
+                panic!("built without the tokio1-boring-tls feature");
+
+                #[cfg(feature = "tokio1-boring-tls")]
+                return {
+                    let mut config = connector.configure().map_err(error::connection)?;
+                    config.set_verify_hostname(tls_parameters.accept_invalid_hostnames);
+
+                    let stream = tokio1_boring::connect(config, &domain, tcp_stream)
+                        .await
+                        .map_err(error::connection)?;
+                    Ok(InnerAsyncNetworkStream::Tokio1BoringTls(stream))
+                };
+            }
         }
     }
 
     #[allow(unused_variables)]
-    #[cfg(any(feature = "async-std1-native-tls", feature = "async-std1-rustls-tls"))]
+    #[cfg(feature = "async-std1-rustls-tls")]
     async fn upgrade_asyncstd1_tls(
         tcp_stream: AsyncStd1TcpStream,
         mut tls_parameters: TlsParameters,
@@ -253,22 +385,6 @@ impl AsyncNetworkStream {
             #[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) => {
@@ -277,39 +393,132 @@ impl AsyncNetworkStream {
 
                 #[cfg(feature = "async-std1-rustls-tls")]
                 return {
-                    use async_rustls::{webpki::DNSNameRef, TlsConnector};
+                    use futures_rustls::TlsConnector;
 
-                    let domain =
-                        DNSNameRef::try_from_ascii_str(&domain).map_err(error::connection)?;
+                    let domain = ServerName::try_from(domain.as_str())
+                        .map_err(|_| error::connection("domain isn't a valid DNS name"))?;
 
                     let connector = TlsConnector::from(config);
                     let stream = connector
-                        .connect(domain, tcp_stream)
+                        .connect(domain.to_owned(), tcp_stream)
                         .await
                         .map_err(error::connection)?;
                     Ok(InnerAsyncNetworkStream::AsyncStd1RustlsTls(stream))
                 };
             }
+            #[cfg(feature = "boring-tls")]
+            InnerTlsParameters::BoringTls(connector) => {
+                panic!("boring-tls isn't supported with async-std yet.");
+            }
         }
     }
 
     pub fn is_encrypted(&self) -> bool {
-        match self.inner {
+        match &self.inner {
             #[cfg(feature = "tokio1")]
             InnerAsyncNetworkStream::Tokio1Tcp(_) => false,
             #[cfg(feature = "tokio1-native-tls")]
             InnerAsyncNetworkStream::Tokio1NativeTls(_) => true,
             #[cfg(feature = "tokio1-rustls-tls")]
             InnerAsyncNetworkStream::Tokio1RustlsTls(_) => true,
+            #[cfg(feature = "tokio1-boring-tls")]
+            InnerAsyncNetworkStream::Tokio1BoringTls(_) => 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,
         }
     }
+
+    pub fn certificate_chain(&self) -> Result<Vec<Vec<u8>>, Error> {
+        match &self.inner {
+            #[cfg(feature = "tokio1")]
+            InnerAsyncNetworkStream::Tokio1Tcp(_) => {
+                Err(error::client("Connection is not encrypted"))
+            }
+            #[cfg(feature = "tokio1-native-tls")]
+            InnerAsyncNetworkStream::Tokio1NativeTls(_) => panic!("Unsupported"),
+            #[cfg(feature = "tokio1-rustls-tls")]
+            InnerAsyncNetworkStream::Tokio1RustlsTls(stream) => Ok(stream
+                .get_ref()
+                .1
+                .peer_certificates()
+                .unwrap()
+                .iter()
+                .map(|c| c.to_vec())
+                .collect()),
+            #[cfg(feature = "tokio1-boring-tls")]
+            InnerAsyncNetworkStream::Tokio1BoringTls(stream) => Ok(stream
+                .ssl()
+                .peer_cert_chain()
+                .unwrap()
+                .iter()
+                .map(|c| c.to_der().map_err(error::tls))
+                .collect::<Result<Vec<_>, _>>()?),
+            #[cfg(feature = "async-std1")]
+            InnerAsyncNetworkStream::AsyncStd1Tcp(_) => {
+                Err(error::client("Connection is not encrypted"))
+            }
+            #[cfg(feature = "async-std1-rustls-tls")]
+            InnerAsyncNetworkStream::AsyncStd1RustlsTls(stream) => Ok(stream
+                .get_ref()
+                .1
+                .peer_certificates()
+                .unwrap()
+                .iter()
+                .map(|c| c.to_vec())
+                .collect()),
+            InnerAsyncNetworkStream::None => panic!("InnerNetworkStream::None must never be built"),
+        }
+    }
+
+    pub fn peer_certificate(&self) -> Result<Vec<u8>, Error> {
+        match &self.inner {
+            #[cfg(feature = "tokio1")]
+            InnerAsyncNetworkStream::Tokio1Tcp(_) => {
+                Err(error::client("Connection is not encrypted"))
+            }
+            #[cfg(feature = "tokio1-native-tls")]
+            InnerAsyncNetworkStream::Tokio1NativeTls(stream) => Ok(stream
+                .get_ref()
+                .peer_certificate()
+                .map_err(error::tls)?
+                .unwrap()
+                .to_der()
+                .map_err(error::tls)?),
+            #[cfg(feature = "tokio1-rustls-tls")]
+            InnerAsyncNetworkStream::Tokio1RustlsTls(stream) => Ok(stream
+                .get_ref()
+                .1
+                .peer_certificates()
+                .unwrap()
+                .first()
+                .unwrap()
+                .to_vec()),
+            #[cfg(feature = "tokio1-boring-tls")]
+            InnerAsyncNetworkStream::Tokio1BoringTls(stream) => Ok(stream
+                .ssl()
+                .peer_certificate()
+                .unwrap()
+                .to_der()
+                .map_err(error::tls)?),
+            #[cfg(feature = "async-std1")]
+            InnerAsyncNetworkStream::AsyncStd1Tcp(_) => {
+                Err(error::client("Connection is not encrypted"))
+            }
+            #[cfg(feature = "async-std1-rustls-tls")]
+            InnerAsyncNetworkStream::AsyncStd1RustlsTls(stream) => Ok(stream
+                .get_ref()
+                .1
+                .peer_certificates()
+                .unwrap()
+                .first()
+                .unwrap()
+                .to_vec()),
+            InnerAsyncNetworkStream::None => panic!("InnerNetworkStream::None must never be built"),
+        }
+    }
 }
 
 impl FuturesAsyncRead for AsyncNetworkStream {
@@ -318,9 +527,9 @@ impl FuturesAsyncRead for AsyncNetworkStream {
         cx: &mut Context<'_>,
         buf: &mut [u8],
     ) -> Poll<IoResult<usize>> {
-        match self.inner {
+        match &mut self.inner {
             #[cfg(feature = "tokio1")]
-            InnerAsyncNetworkStream::Tokio1Tcp(ref mut s) => {
+            InnerAsyncNetworkStream::Tokio1Tcp(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())),
@@ -329,7 +538,7 @@ impl FuturesAsyncRead for AsyncNetworkStream {
                 }
             }
             #[cfg(feature = "tokio1-native-tls")]
-            InnerAsyncNetworkStream::Tokio1NativeTls(ref mut s) => {
+            InnerAsyncNetworkStream::Tokio1NativeTls(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())),
@@ -338,7 +547,16 @@ impl FuturesAsyncRead for AsyncNetworkStream {
                 }
             }
             #[cfg(feature = "tokio1-rustls-tls")]
-            InnerAsyncNetworkStream::Tokio1RustlsTls(ref mut s) => {
+            InnerAsyncNetworkStream::Tokio1RustlsTls(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-boring-tls")]
+            InnerAsyncNetworkStream::Tokio1BoringTls(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())),
@@ -347,15 +565,9 @@ impl FuturesAsyncRead for AsyncNetworkStream {
                 }
             }
             #[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)
-            }
+            InnerAsyncNetworkStream::AsyncStd1Tcp(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::AsyncStd1RustlsTls(s) => Pin::new(s).poll_read(cx, buf),
             InnerAsyncNetworkStream::None => {
                 debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
                 Poll::Ready(Ok(0))
@@ -370,23 +582,19 @@ impl FuturesAsyncWrite for AsyncNetworkStream {
         cx: &mut Context<'_>,
         buf: &[u8],
     ) -> Poll<IoResult<usize>> {
-        match self.inner {
+        match &mut self.inner {
             #[cfg(feature = "tokio1")]
-            InnerAsyncNetworkStream::Tokio1Tcp(ref mut s) => Pin::new(s).poll_write(cx, buf),
+            InnerAsyncNetworkStream::Tokio1Tcp(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),
+            InnerAsyncNetworkStream::Tokio1NativeTls(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),
+            InnerAsyncNetworkStream::Tokio1RustlsTls(s) => Pin::new(s).poll_write(cx, buf),
+            #[cfg(feature = "tokio1-boring-tls")]
+            InnerAsyncNetworkStream::Tokio1BoringTls(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)
-            }
+            InnerAsyncNetworkStream::AsyncStd1Tcp(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::AsyncStd1RustlsTls(s) => Pin::new(s).poll_write(cx, buf),
             InnerAsyncNetworkStream::None => {
                 debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
                 Poll::Ready(Ok(0))
@@ -395,19 +603,19 @@ impl FuturesAsyncWrite for AsyncNetworkStream {
     }
 
     fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<IoResult<()>> {
-        match self.inner {
+        match &mut self.inner {
             #[cfg(feature = "tokio1")]
-            InnerAsyncNetworkStream::Tokio1Tcp(ref mut s) => Pin::new(s).poll_flush(cx),
+            InnerAsyncNetworkStream::Tokio1Tcp(s) => Pin::new(s).poll_flush(cx),
             #[cfg(feature = "tokio1-native-tls")]
-            InnerAsyncNetworkStream::Tokio1NativeTls(ref mut s) => Pin::new(s).poll_flush(cx),
+            InnerAsyncNetworkStream::Tokio1NativeTls(s) => Pin::new(s).poll_flush(cx),
             #[cfg(feature = "tokio1-rustls-tls")]
-            InnerAsyncNetworkStream::Tokio1RustlsTls(ref mut s) => Pin::new(s).poll_flush(cx),
+            InnerAsyncNetworkStream::Tokio1RustlsTls(s) => Pin::new(s).poll_flush(cx),
+            #[cfg(feature = "tokio1-boring-tls")]
+            InnerAsyncNetworkStream::Tokio1BoringTls(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),
+            InnerAsyncNetworkStream::AsyncStd1Tcp(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::AsyncStd1RustlsTls(s) => Pin::new(s).poll_flush(cx),
             InnerAsyncNetworkStream::None => {
                 debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
                 Poll::Ready(Ok(()))
@@ -416,19 +624,19 @@ impl FuturesAsyncWrite for AsyncNetworkStream {
     }
 
     fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<IoResult<()>> {
-        match self.inner {
+        match &mut self.inner {
             #[cfg(feature = "tokio1")]
-            InnerAsyncNetworkStream::Tokio1Tcp(ref mut s) => Pin::new(s).poll_shutdown(cx),
+            InnerAsyncNetworkStream::Tokio1Tcp(s) => Pin::new(s).poll_shutdown(cx),
             #[cfg(feature = "tokio1-native-tls")]
-            InnerAsyncNetworkStream::Tokio1NativeTls(ref mut s) => Pin::new(s).poll_shutdown(cx),
+            InnerAsyncNetworkStream::Tokio1NativeTls(s) => Pin::new(s).poll_shutdown(cx),
             #[cfg(feature = "tokio1-rustls-tls")]
-            InnerAsyncNetworkStream::Tokio1RustlsTls(ref mut s) => Pin::new(s).poll_shutdown(cx),
+            InnerAsyncNetworkStream::Tokio1RustlsTls(s) => Pin::new(s).poll_shutdown(cx),
+            #[cfg(feature = "tokio1-boring-tls")]
+            InnerAsyncNetworkStream::Tokio1BoringTls(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),
+            InnerAsyncNetworkStream::AsyncStd1Tcp(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::AsyncStd1RustlsTls(s) => Pin::new(s).poll_close(cx),
             InnerAsyncNetworkStream::None => {
                 debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
                 Poll::Ready(Ok(()))

src/transport/smtp/client/connection.rs

@@ -1,16 +1,18 @@
 use std::{
     fmt::Display,
     io::{self, BufRead, BufReader, Write},
-    net::ToSocketAddrs,
+    net::{IpAddr, ToSocketAddrs},
     time::Duration,
 };
 
+#[cfg(feature = "tracing")]
+use super::escape_crlf;
 use super::{ClientCodec, NetworkStream, TlsParameters};
 use crate::{
     address::Envelope,
     transport::smtp::{
         authentication::{Credentials, Mechanism},
-        commands::*,
+        commands::{Auth, Data, Ehlo, Mail, Noop, Quit, Rcpt, Starttls},
         error,
         error::Error,
         extension::{ClientId, Extension, MailBodyParameter, MailParameter, ServerInfo},
@@ -18,9 +20,6 @@ use crate::{
     },
 };
 
-#[cfg(feature = "tracing")]
-use super::escape_crlf;
-
 macro_rules! try_smtp (
     ($err: expr, $client: ident) => ({
         match $err {
@@ -45,6 +44,7 @@ pub struct SmtpConnection {
 }
 
 impl SmtpConnection {
+    /// Get information about the server
     pub fn server_info(&self) -> &ServerInfo {
         &self.server_info
     }
@@ -59,8 +59,9 @@ impl SmtpConnection {
         timeout: Option<Duration>,
         hello_name: &ClientId,
         tls_parameters: Option<&TlsParameters>,
+        local_address: Option<IpAddr>,
     ) -> Result<SmtpConnection, Error> {
-        let stream = NetworkStream::connect(server, timeout, tls_parameters)?;
+        let stream = NetworkStream::connect(server, timeout, tls_parameters, local_address)?;
         let stream = BufReader::new(stream);
         let mut conn = SmtpConnection {
             stream,
@@ -99,7 +100,7 @@ impl SmtpConnection {
             mail_options.push(MailParameter::SmtpUtfEight);
         }
 
-        // Check for non-ascii content in message
+        // Check for non-ascii content in the message
         if !email.is_ascii() {
             if !self.server_info().supports_feature(Extension::EightBitMime) {
                 return Err(error::client(
@@ -142,17 +143,21 @@ impl SmtpConnection {
         hello_name: &ClientId,
     ) -> Result<(), Error> {
         if self.server_info.supports_feature(Extension::StartTls) {
-            #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+            #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
             {
                 try_smtp!(self.command(Starttls), self);
-                try_smtp!(self.stream.get_mut().upgrade_tls(tls_parameters), self);
+                self.stream.get_mut().upgrade_tls(tls_parameters)?;
                 #[cfg(feature = "tracing")]
                 tracing::debug!("connection encrypted");
                 // Send EHLO again
                 try_smtp!(self.ehlo(hello_name), self);
                 Ok(())
             }
-            #[cfg(not(any(feature = "native-tls", feature = "rustls-tls")))]
+            #[cfg(not(any(
+                feature = "native-tls",
+                feature = "rustls-tls",
+                feature = "boring-tls"
+            )))]
             // This should never happen as `Tls` can only be created
             // when a TLS library is enabled
             unreachable!("TLS support required but not supported");
@@ -178,6 +183,7 @@ impl SmtpConnection {
             self.panic = true;
             let _ = self.command(Quit);
         }
+        let _ = self.stream.get_mut().shutdown(std::net::Shutdown::Both);
     }
 
     /// Sets the underlying stream
@@ -201,7 +207,7 @@ impl SmtpConnection {
         self.command(Noop).is_ok()
     }
 
-    /// Sends an AUTH command with the given mechanism, and handles challenge if needed
+    /// Sends an AUTH command with the given mechanism, and handles the challenge if needed
     pub fn auth(
         &mut self,
         mechanisms: &[Mechanism],
@@ -237,11 +243,12 @@ impl SmtpConnection {
 
     /// Sends the message content
     pub fn message(&mut self, message: &[u8]) -> Result<Response, Error> {
-        let mut out_buf: Vec<u8> = vec![];
         let mut codec = ClientCodec::new();
+        let mut out_buf = Vec::with_capacity(message.len());
         codec.encode(message, &mut out_buf);
         self.write(out_buf.as_slice())?;
         self.write(b"\r\n.\r\n")?;
+
         self.read_response()
     }
 
@@ -276,7 +283,10 @@ impl SmtpConnection {
                     return if response.is_positive() {
                         Ok(response)
                     } else {
-                        Err(error::code(response.code))
+                        Err(error::code(
+                            response.code(),
+                            Some(response.message().collect()),
+                        ))
                     };
                 }
                 Err(nom::Err::Failure(e)) => {
@@ -291,4 +301,16 @@ impl SmtpConnection {
 
         Err(error::response("incomplete response"))
     }
+
+    /// The X509 certificate of the server (DER encoded)
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    pub fn peer_certificate(&self) -> Result<Vec<u8>, Error> {
+        self.stream.get_ref().peer_certificate()
+    }
+
+    /// All the X509 certificates of the chain (DER encoded)
+    #[cfg(any(feature = "rustls-tls", feature = "boring-tls"))]
+    pub fn certificate_chain(&self) -> Result<Vec<Vec<u8>>, Error> {
+        self.stream.get_ref().certificate_chain()
+    }
 }

src/transport/smtp/client/mod.rs

@@ -7,16 +7,14 @@
 //!
 //! # #[cfg(feature = "smtp-transport")]
 //! # fn main() -> Result<(), Box<dyn Error>> {
-//! use lettre::transport::smtp::{SMTP_PORT, extension::ClientId, commands::*, client::SmtpConnection};
+//! use lettre::transport::smtp::{
+//!     client::SmtpConnection, commands::*, extension::ClientId, SMTP_PORT,
+//! };
 //!
-//! let hello = ClientId::Domain("my_hostname".to_string());
-//! let mut client = SmtpConnection::connect(&("localhost", SMTP_PORT), None, &hello, None)?;
-//! client.command(
-//!         Mail::new(Some("user@example.com".parse()?), vec![])
-//!     )?;
-//! client.command(
-//!         Rcpt::new("user@example.org".parse()?, vec![])
-//!       )?;
+//! let hello = ClientId::Domain("my_hostname".to_owned());
+//! let mut client = SmtpConnection::connect(&("localhost", SMTP_PORT), None, &hello, None, None)?;
+//! client.command(Mail::new(Some("user@example.com".parse()?), vec![]))?;
+//! client.command(Rcpt::new("user@example.org".parse()?, vec![]))?;
 //! client.command(Data)?;
 //! client.message("Test email".as_bytes())?;
 //! client.command(Quit)?;
@@ -28,15 +26,19 @@
 use std::fmt::Debug;
 
 #[cfg(any(feature = "tokio1", feature = "async-std1"))]
-pub(crate) use self::async_connection::AsyncSmtpConnection;
+pub use self::async_connection::AsyncSmtpConnection;
 #[cfg(any(feature = "tokio1", feature = "async-std1"))]
-pub(crate) use self::async_net::AsyncNetworkStream;
+pub use self::async_net::AsyncNetworkStream;
+#[cfg(feature = "tokio1")]
+pub use self::async_net::AsyncTokioStream;
 use self::net::NetworkStream;
-#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+#[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
 pub(super) use self::tls::InnerTlsParameters;
+#[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+pub use self::tls::TlsVersion;
 pub use self::{
     connection::SmtpConnection,
-    tls::{Certificate, Tls, TlsParameters, TlsParametersBuilder},
+    tls::{Certificate, CertificateStore, Identity, Tls, TlsParameters, TlsParametersBuilder},
 };
 
 #[cfg(any(feature = "tokio1", feature = "async-std1"))]
@@ -48,52 +50,57 @@ mod net;
 mod tls;
 
 /// The codec used for transparency
-#[derive(Default, Clone, Copy, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Debug)]
 struct ClientCodec {
-    escape_count: u8,
+    status: CodecStatus,
 }
 
 impl ClientCodec {
     /// Creates a new client codec
     pub fn new() -> Self {
-        ClientCodec::default()
+        Self {
+            status: CodecStatus::StartOfNewLine,
+        }
     }
 
     /// Adds transparency
     fn encode(&mut self, frame: &[u8], buf: &mut Vec<u8>) {
-        match frame.len() {
-            0 => {
-                match self.escape_count {
-                    0 => buf.extend_from_slice(b"\r\n.\r\n"),
-                    1 => buf.extend_from_slice(b"\n.\r\n"),
-                    2 => buf.extend_from_slice(b".\r\n"),
-                    _ => unreachable!(),
+        for &b in frame {
+            buf.push(b);
+            match (b, self.status) {
+                (b'\r', _) => {
+                    self.status = CodecStatus::StartingNewLine;
                 }
-                self.escape_count = 0;
-            }
-            _ => {
-                let mut start = 0;
-                for (idx, byte) in frame.iter().enumerate() {
-                    match self.escape_count {
-                        0 => self.escape_count = if *byte == b'\r' { 1 } else { 0 },
-                        1 => self.escape_count = if *byte == b'\n' { 2 } else { 0 },
-                        2 => self.escape_count = if *byte == b'.' { 3 } else { 0 },
-                        _ => unreachable!(),
-                    }
-                    if self.escape_count == 3 {
-                        self.escape_count = 0;
-                        buf.extend_from_slice(&frame[start..idx]);
-                        buf.extend_from_slice(b".");
-                        start = idx;
-                    }
+                (b'\n', CodecStatus::StartingNewLine) => {
+                    self.status = CodecStatus::StartOfNewLine;
                 }
-                buf.extend_from_slice(&frame[start..]);
+                (_, CodecStatus::StartingNewLine) => {
+                    self.status = CodecStatus::MiddleOfLine;
+                }
+                (b'.', CodecStatus::StartOfNewLine) => {
+                    self.status = CodecStatus::MiddleOfLine;
+                    buf.push(b'.');
+                }
+                (_, CodecStatus::StartOfNewLine) => {
+                    self.status = CodecStatus::MiddleOfLine;
+                }
+                _ => {}
             }
         }
     }
 }
 
+#[derive(Debug, Copy, Clone)]
+#[allow(clippy::enum_variant_names)]
+enum CodecStatus {
+    /// We are past the first character of the current line
+    MiddleOfLine,
+    /// We just read a `\r` character
+    StartingNewLine,
+    /// We are at the start of a new line
+    StartOfNewLine,
+}
+
 /// Returns the string replacing all the CRLF with "\<CRLF\>"
 /// Used for debug displays
 #[cfg(feature = "tracing")]
@@ -107,10 +114,12 @@ mod test {
 
     #[test]
     fn test_codec() {
+        let mut buf = Vec::new();
         let mut codec = ClientCodec::new();
-        let mut buf: Vec<u8> = vec![];
 
+        codec.encode(b".\r\n", &mut buf);
         codec.encode(b"test\r\n", &mut buf);
+        codec.encode(b"test\r\n\r\n", &mut buf);
         codec.encode(b".\r\n", &mut buf);
         codec.encode(b"\r\ntest", &mut buf);
         codec.encode(b"te\r\n.\r\nst", &mut buf);
@@ -119,14 +128,18 @@ mod test {
         codec.encode(b"test\n", &mut buf);
         codec.encode(b".test\n", &mut buf);
         codec.encode(b"test", &mut buf);
+        codec.encode(b"test", &mut buf);
+        codec.encode(b"test\r\n", &mut buf);
+        codec.encode(b".test\r\n", &mut buf);
+        codec.encode(b"test.\r\n", &mut buf);
         assert_eq!(
             String::from_utf8(buf).unwrap(),
-            "test\r\n..\r\n\r\ntestte\r\n..\r\nsttesttest.test\n.test\ntest"
+            "..\r\ntest\r\ntest\r\n\r\n..\r\n\r\ntestte\r\n..\r\nsttesttest.test\n.test\ntesttesttest\r\n..test\r\ntest.\r\n"
         );
     }
 
     #[test]
-    #[cfg(feature = "log")]
+    #[cfg(feature = "tracing")]
     fn test_escape_crlf() {
         assert_eq!(escape_crlf("\r\n"), "<CRLF>");
         assert_eq!(escape_crlf("EHLO my_name\r\n"), "EHLO my_name<CRLF>");

src/transport/smtp/client/net.rs

@@ -1,17 +1,21 @@
+#[cfg(feature = "rustls-tls")]
+use std::sync::Arc;
 use std::{
     io::{self, Read, Write},
     mem,
-    net::{Ipv4Addr, Shutdown, SocketAddr, SocketAddrV4, TcpStream, ToSocketAddrs},
+    net::{IpAddr, Ipv4Addr, Shutdown, SocketAddr, SocketAddrV4, TcpStream, ToSocketAddrs},
     time::Duration,
 };
 
+#[cfg(feature = "boring-tls")]
+use boring::ssl::SslStream;
 #[cfg(feature = "native-tls")]
 use native_tls::TlsStream;
-
 #[cfg(feature = "rustls-tls")]
-use rustls::{ClientSession, StreamOwned};
+use rustls::{pki_types::ServerName, ClientConnection, StreamOwned};
+use socket2::{Domain, Protocol, Type};
 
-#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+#[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
 use super::InnerTlsParameters;
 use super::TlsParameters;
 use crate::transport::smtp::{error, Error};
@@ -33,7 +37,9 @@ enum InnerNetworkStream {
     NativeTls(TlsStream<TcpStream>),
     /// Encrypted TCP stream
     #[cfg(feature = "rustls-tls")]
-    RustlsTls(StreamOwned<ClientSession, TcpStream>),
+    RustlsTls(StreamOwned<ClientConnection, TcpStream>),
+    #[cfg(feature = "boring-tls")]
+    BoringTls(SslStream<TcpStream>),
     /// Can't be built
     None,
 }
@@ -49,12 +55,14 @@ impl NetworkStream {
 
     /// Returns peer's address
     pub fn peer_addr(&self) -> io::Result<SocketAddr> {
-        match self.inner {
-            InnerNetworkStream::Tcp(ref s) => s.peer_addr(),
+        match &self.inner {
+            InnerNetworkStream::Tcp(s) => s.peer_addr(),
             #[cfg(feature = "native-tls")]
-            InnerNetworkStream::NativeTls(ref s) => s.get_ref().peer_addr(),
+            InnerNetworkStream::NativeTls(s) => s.get_ref().peer_addr(),
             #[cfg(feature = "rustls-tls")]
-            InnerNetworkStream::RustlsTls(ref s) => s.get_ref().peer_addr(),
+            InnerNetworkStream::RustlsTls(s) => s.get_ref().peer_addr(),
+            #[cfg(feature = "boring-tls")]
+            InnerNetworkStream::BoringTls(s) => s.get_ref().peer_addr(),
             InnerNetworkStream::None => {
                 debug_assert!(false, "InnerNetworkStream::None must never be built");
                 Ok(SocketAddr::V4(SocketAddrV4::new(
@@ -67,12 +75,14 @@ impl NetworkStream {
 
     /// Shutdowns the connection
     pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
-        match self.inner {
-            InnerNetworkStream::Tcp(ref s) => s.shutdown(how),
+        match &self.inner {
+            InnerNetworkStream::Tcp(s) => s.shutdown(how),
             #[cfg(feature = "native-tls")]
-            InnerNetworkStream::NativeTls(ref s) => s.get_ref().shutdown(how),
+            InnerNetworkStream::NativeTls(s) => s.get_ref().shutdown(how),
             #[cfg(feature = "rustls-tls")]
-            InnerNetworkStream::RustlsTls(ref s) => s.get_ref().shutdown(how),
+            InnerNetworkStream::RustlsTls(s) => s.get_ref().shutdown(how),
+            #[cfg(feature = "boring-tls")]
+            InnerNetworkStream::BoringTls(s) => s.get_ref().shutdown(how),
             InnerNetworkStream::None => {
                 debug_assert!(false, "InnerNetworkStream::None must never be built");
                 Ok(())
@@ -84,25 +94,49 @@ impl NetworkStream {
         server: T,
         timeout: Option<Duration>,
         tls_parameters: Option<&TlsParameters>,
+        local_addr: Option<IpAddr>,
     ) -> Result<NetworkStream, Error> {
-        fn try_connect_timeout<T: ToSocketAddrs>(
+        fn try_connect<T: ToSocketAddrs>(
             server: T,
-            timeout: Duration,
+            timeout: Option<Duration>,
+            local_addr: Option<IpAddr>,
         ) -> Result<TcpStream, Error> {
-            let addrs = server.to_socket_addrs().map_err(error::connection)?;
+            let addrs = server
+                .to_socket_addrs()
+                .map_err(error::connection)?
+                .filter(|resolved_addr| resolved_address_filter(resolved_addr, local_addr));
+
+            let mut last_err = None;
+
             for addr in addrs {
-                if let Ok(result) = TcpStream::connect_timeout(&addr, timeout) {
-                    return Ok(result);
+                let socket = socket2::Socket::new(
+                    Domain::for_address(addr),
+                    Type::STREAM,
+                    Some(Protocol::TCP),
+                )
+                .map_err(error::connection)?;
+                bind_local_address(&socket, &addr, local_addr)?;
+
+                if let Some(timeout) = timeout {
+                    match socket.connect_timeout(&addr.into(), timeout) {
+                        Ok(_) => return Ok(socket.into()),
+                        Err(err) => last_err = Some(err),
+                    }
+                } else {
+                    match socket.connect(&addr.into()) {
+                        Ok(_) => return Ok(socket.into()),
+                        Err(err) => last_err = Some(err),
+                    }
                 }
             }
-            Err(error::connection("Could not connect"))
+
+            Err(match last_err {
+                Some(last_err) => error::connection(last_err),
+                None => error::connection("could not resolve to any address"),
+            })
         }
 
-        let tcp_stream = match timeout {
-            Some(t) => try_connect_timeout(server, t)?,
-            None => TcpStream::connect(server).map_err(error::connection)?,
-        };
-
+        let tcp_stream = try_connect(server, timeout, local_addr)?;
         let mut stream = NetworkStream::new(InnerNetworkStream::Tcp(tcp_stream));
         if let Some(tls_parameters) = tls_parameters {
             stream.upgrade_tls(tls_parameters)?;
@@ -112,13 +146,17 @@ impl NetworkStream {
 
     pub fn upgrade_tls(&mut self, tls_parameters: &TlsParameters) -> Result<(), Error> {
         match &self.inner {
-            #[cfg(not(any(feature = "native-tls", feature = "rustls-tls")))]
+            #[cfg(not(any(
+                feature = "native-tls",
+                feature = "rustls-tls",
+                feature = "boring-tls"
+            )))]
             InnerNetworkStream::Tcp(_) => {
                 let _ = tls_parameters;
                 panic!("Trying to upgrade an NetworkStream without having enabled either the native-tls or the rustls-tls feature");
             }
 
-            #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+            #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
             InnerNetworkStream::Tcp(_) => {
                 // get owned TcpStream
                 let tcp_stream = mem::replace(&mut self.inner, InnerNetworkStream::None);
@@ -134,7 +172,7 @@ impl NetworkStream {
         }
     }
 
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
     fn upgrade_tls_impl(
         tcp_stream: TcpStream,
         tls_parameters: &TlsParameters,
@@ -149,24 +187,35 @@ impl NetworkStream {
             }
             #[cfg(feature = "rustls-tls")]
             InnerTlsParameters::RustlsTls(connector) => {
-                use webpki::DNSNameRef;
-
-                let domain = DNSNameRef::try_from_ascii_str(tls_parameters.domain())
+                let domain = ServerName::try_from(tls_parameters.domain())
+                    .map_err(|_| error::connection("domain isn't a valid DNS name"))?;
+                let connection = ClientConnection::new(Arc::clone(connector), domain.to_owned())
                     .map_err(error::connection)?;
-                let stream = StreamOwned::new(ClientSession::new(&connector, domain), tcp_stream);
-
+                let stream = StreamOwned::new(connection, tcp_stream);
                 InnerNetworkStream::RustlsTls(stream)
             }
+            #[cfg(feature = "boring-tls")]
+            InnerTlsParameters::BoringTls(connector) => {
+                let stream = connector
+                    .configure()
+                    .map_err(error::connection)?
+                    .verify_hostname(tls_parameters.accept_invalid_hostnames)
+                    .connect(tls_parameters.domain(), tcp_stream)
+                    .map_err(error::connection)?;
+                InnerNetworkStream::BoringTls(stream)
+            }
         })
     }
 
     pub fn is_encrypted(&self) -> bool {
-        match self.inner {
+        match &self.inner {
             InnerNetworkStream::Tcp(_) => false,
             #[cfg(feature = "native-tls")]
             InnerNetworkStream::NativeTls(_) => true,
             #[cfg(feature = "rustls-tls")]
             InnerNetworkStream::RustlsTls(_) => true,
+            #[cfg(feature = "boring-tls")]
+            InnerNetworkStream::BoringTls(_) => true,
             InnerNetworkStream::None => {
                 debug_assert!(false, "InnerNetworkStream::None must never be built");
                 false
@@ -174,17 +223,71 @@ impl NetworkStream {
         }
     }
 
-    pub fn set_read_timeout(&mut self, duration: Option<Duration>) -> io::Result<()> {
-        match self.inner {
-            InnerNetworkStream::Tcp(ref mut stream) => stream.set_read_timeout(duration),
+    #[cfg(any(feature = "rustls-tls", feature = "boring-tls"))]
+    pub fn certificate_chain(&self) -> Result<Vec<Vec<u8>>, Error> {
+        match &self.inner {
+            InnerNetworkStream::Tcp(_) => Err(error::client("Connection is not encrypted")),
             #[cfg(feature = "native-tls")]
-            InnerNetworkStream::NativeTls(ref mut stream) => {
-                stream.get_ref().set_read_timeout(duration)
-            }
+            InnerNetworkStream::NativeTls(_) => panic!("Unsupported"),
             #[cfg(feature = "rustls-tls")]
-            InnerNetworkStream::RustlsTls(ref mut stream) => {
-                stream.get_ref().set_read_timeout(duration)
-            }
+            InnerNetworkStream::RustlsTls(stream) => Ok(stream
+                .conn
+                .peer_certificates()
+                .unwrap()
+                .iter()
+                .map(|c| c.to_vec())
+                .collect()),
+            #[cfg(feature = "boring-tls")]
+            InnerNetworkStream::BoringTls(stream) => Ok(stream
+                .ssl()
+                .peer_cert_chain()
+                .unwrap()
+                .iter()
+                .map(|c| c.to_der().map_err(error::tls))
+                .collect::<Result<Vec<_>, _>>()?),
+            InnerNetworkStream::None => panic!("InnerNetworkStream::None must never be built"),
+        }
+    }
+
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    pub fn peer_certificate(&self) -> Result<Vec<u8>, Error> {
+        match &self.inner {
+            InnerNetworkStream::Tcp(_) => Err(error::client("Connection is not encrypted")),
+            #[cfg(feature = "native-tls")]
+            InnerNetworkStream::NativeTls(stream) => Ok(stream
+                .peer_certificate()
+                .map_err(error::tls)?
+                .unwrap()
+                .to_der()
+                .map_err(error::tls)?),
+            #[cfg(feature = "rustls-tls")]
+            InnerNetworkStream::RustlsTls(stream) => Ok(stream
+                .conn
+                .peer_certificates()
+                .unwrap()
+                .first()
+                .unwrap()
+                .to_vec()),
+            #[cfg(feature = "boring-tls")]
+            InnerNetworkStream::BoringTls(stream) => Ok(stream
+                .ssl()
+                .peer_certificate()
+                .unwrap()
+                .to_der()
+                .map_err(error::tls)?),
+            InnerNetworkStream::None => panic!("InnerNetworkStream::None must never be built"),
+        }
+    }
+
+    pub fn set_read_timeout(&mut self, duration: Option<Duration>) -> io::Result<()> {
+        match &mut self.inner {
+            InnerNetworkStream::Tcp(stream) => stream.set_read_timeout(duration),
+            #[cfg(feature = "native-tls")]
+            InnerNetworkStream::NativeTls(stream) => stream.get_ref().set_read_timeout(duration),
+            #[cfg(feature = "rustls-tls")]
+            InnerNetworkStream::RustlsTls(stream) => stream.get_ref().set_read_timeout(duration),
+            #[cfg(feature = "boring-tls")]
+            InnerNetworkStream::BoringTls(stream) => stream.get_ref().set_read_timeout(duration),
             InnerNetworkStream::None => {
                 debug_assert!(false, "InnerNetworkStream::None must never be built");
                 Ok(())
@@ -194,18 +297,15 @@ impl NetworkStream {
 
     /// Set write timeout for IO calls
     pub fn set_write_timeout(&mut self, duration: Option<Duration>) -> io::Result<()> {
-        match self.inner {
-            InnerNetworkStream::Tcp(ref mut stream) => stream.set_write_timeout(duration),
+        match &mut self.inner {
+            InnerNetworkStream::Tcp(stream) => stream.set_write_timeout(duration),
 
             #[cfg(feature = "native-tls")]
-            InnerNetworkStream::NativeTls(ref mut stream) => {
-                stream.get_ref().set_write_timeout(duration)
-            }
+            InnerNetworkStream::NativeTls(stream) => stream.get_ref().set_write_timeout(duration),
             #[cfg(feature = "rustls-tls")]
-            InnerNetworkStream::RustlsTls(ref mut stream) => {
-                stream.get_ref().set_write_timeout(duration)
-            }
-
+            InnerNetworkStream::RustlsTls(stream) => stream.get_ref().set_write_timeout(duration),
+            #[cfg(feature = "boring-tls")]
+            InnerNetworkStream::BoringTls(stream) => stream.get_ref().set_write_timeout(duration),
             InnerNetworkStream::None => {
                 debug_assert!(false, "InnerNetworkStream::None must never be built");
                 Ok(())
@@ -216,12 +316,14 @@ impl NetworkStream {
 
 impl Read for NetworkStream {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        match self.inner {
-            InnerNetworkStream::Tcp(ref mut s) => s.read(buf),
+        match &mut self.inner {
+            InnerNetworkStream::Tcp(s) => s.read(buf),
             #[cfg(feature = "native-tls")]
-            InnerNetworkStream::NativeTls(ref mut s) => s.read(buf),
+            InnerNetworkStream::NativeTls(s) => s.read(buf),
             #[cfg(feature = "rustls-tls")]
-            InnerNetworkStream::RustlsTls(ref mut s) => s.read(buf),
+            InnerNetworkStream::RustlsTls(s) => s.read(buf),
+            #[cfg(feature = "boring-tls")]
+            InnerNetworkStream::BoringTls(s) => s.read(buf),
             InnerNetworkStream::None => {
                 debug_assert!(false, "InnerNetworkStream::None must never be built");
                 Ok(0)
@@ -232,12 +334,14 @@ impl Read for NetworkStream {
 
 impl Write for NetworkStream {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        match self.inner {
-            InnerNetworkStream::Tcp(ref mut s) => s.write(buf),
+        match &mut self.inner {
+            InnerNetworkStream::Tcp(s) => s.write(buf),
             #[cfg(feature = "native-tls")]
-            InnerNetworkStream::NativeTls(ref mut s) => s.write(buf),
+            InnerNetworkStream::NativeTls(s) => s.write(buf),
             #[cfg(feature = "rustls-tls")]
-            InnerNetworkStream::RustlsTls(ref mut s) => s.write(buf),
+            InnerNetworkStream::RustlsTls(s) => s.write(buf),
+            #[cfg(feature = "boring-tls")]
+            InnerNetworkStream::BoringTls(s) => s.write(buf),
             InnerNetworkStream::None => {
                 debug_assert!(false, "InnerNetworkStream::None must never be built");
                 Ok(0)
@@ -246,12 +350,14 @@ impl Write for NetworkStream {
     }
 
     fn flush(&mut self) -> io::Result<()> {
-        match self.inner {
-            InnerNetworkStream::Tcp(ref mut s) => s.flush(),
+        match &mut self.inner {
+            InnerNetworkStream::Tcp(s) => s.flush(),
             #[cfg(feature = "native-tls")]
-            InnerNetworkStream::NativeTls(ref mut s) => s.flush(),
+            InnerNetworkStream::NativeTls(s) => s.flush(),
             #[cfg(feature = "rustls-tls")]
-            InnerNetworkStream::RustlsTls(ref mut s) => s.flush(),
+            InnerNetworkStream::RustlsTls(s) => s.flush(),
+            #[cfg(feature = "boring-tls")]
+            InnerNetworkStream::BoringTls(s) => s.flush(),
             InnerNetworkStream::None => {
                 debug_assert!(false, "InnerNetworkStream::None must never be built");
                 Ok(())
@@ -259,3 +365,47 @@ impl Write for NetworkStream {
         }
     }
 }
+
+/// If the local address is set, binds the socket to this address.
+/// If local address is not set, then destination address is required to determine the default
+/// local address on some platforms.
+/// See: https://github.com/hyperium/hyper/blob/faf24c6ad8eee1c3d5ccc9a4d4835717b8e2903f/src/client/connect/http.rs#L560
+fn bind_local_address(
+    socket: &socket2::Socket,
+    dst_addr: &SocketAddr,
+    local_addr: Option<IpAddr>,
+) -> Result<(), Error> {
+    match local_addr {
+        Some(local_addr) => {
+            socket
+                .bind(&SocketAddr::new(local_addr, 0).into())
+                .map_err(error::connection)?;
+        }
+        _ => {
+            if cfg!(windows) {
+                // Windows requires a socket be bound before calling connect
+                let any: SocketAddr = match dst_addr {
+                    SocketAddr::V4(_) => ([0, 0, 0, 0], 0).into(),
+                    SocketAddr::V6(_) => ([0, 0, 0, 0, 0, 0, 0, 0], 0).into(),
+                };
+                socket.bind(&any.into()).map_err(error::connection)?;
+            }
+        }
+    }
+    Ok(())
+}
+
+/// When we have an iterator of resolved remote addresses, we must filter them to be the same
+/// protocol as the local address binding. If no local address is set, then all will be matched.
+pub(crate) fn resolved_address_filter(
+    resolved_addr: &SocketAddr,
+    local_addr: Option<IpAddr>,
+) -> bool {
+    match local_addr {
+        Some(local_addr) => match resolved_addr.ip() {
+            IpAddr::V4(_) => local_addr.is_ipv4(),
+            IpAddr::V6(_) => local_addr.is_ipv6(),
+        },
+        None => true,
+    }
+}

src/transport/smtp/client/tls.rs

@@ -1,20 +1,63 @@
-#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-use crate::transport::smtp::{error, Error};
+use std::fmt::{self, Debug};
+#[cfg(feature = "rustls-tls")]
+use std::{io, sync::Arc};
+
+#[cfg(feature = "boring-tls")]
+use boring::{
+    pkey::PKey,
+    ssl::{SslConnector, SslVersion},
+    x509::store::X509StoreBuilder,
+};
 #[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::{
+    client::danger::{HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier},
+    crypto::WebPkiSupportedAlgorithms,
+    crypto::{verify_tls12_signature, verify_tls13_signature},
+    pki_types::{CertificateDer, PrivateKeyDer, ServerName, UnixTime},
+    server::ParsedCertificate,
+    ClientConfig, DigitallySignedStruct, Error as TlsError, RootCertStore, SignatureScheme,
+};
 
-/// Accepted protocols by default.
-/// This removes TLS 1.0 and 1.1 compared to tls-native defaults.
-// This is also rustls' default behavior
-#[cfg(feature = "native-tls")]
-const DEFAULT_TLS_MIN_PROTOCOL: Protocol = Protocol::Tlsv12;
+#[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+use crate::transport::smtp::{error, Error};
+
+/// TLS protocol versions.
+#[derive(Debug, Copy, Clone)]
+#[non_exhaustive]
+#[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+pub enum TlsVersion {
+    /// TLS 1.0
+    ///
+    /// Should only be used when trying to support legacy
+    /// SMTP servers that haven't updated to
+    /// at least TLS 1.2 yet.
+    ///
+    /// Supported by `native-tls` and `boring-tls`.
+    Tlsv10,
+    /// TLS 1.1
+    ///
+    /// Should only be used when trying to support legacy
+    /// SMTP servers that haven't updated to
+    /// at least TLS 1.2 yet.
+    ///
+    /// Supported by `native-tls` and `boring-tls`.
+    Tlsv11,
+    /// TLS 1.2
+    ///
+    /// A good option for most SMTP servers.
+    ///
+    /// Supported by all TLS backends.
+    Tlsv12,
+    /// TLS 1.3
+    ///
+    /// The most secure option, although not supported by all SMTP servers.
+    ///
+    /// Although it is technically supported by all TLS backends,
+    /// trying to set it for `native-tls` will give a runtime error.
+    Tlsv13,
+}
 
 /// How to apply TLS to a client connection
 #[derive(Clone)]
@@ -23,16 +66,25 @@ pub enum Tls {
     /// Insecure connection only (for testing purposes)
     None,
     /// Start with insecure connection and use `STARTTLS` when available
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
     Opportunistic(TlsParameters),
     /// Start with insecure connection and require `STARTTLS`
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
     Required(TlsParameters),
     /// Use TLS wrapped connection
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
     Wrapper(TlsParameters),
 }
 
@@ -40,31 +92,61 @@ 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"))]
+            #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
             Self::Opportunistic(_) => f.pad("Opportunistic"),
-            #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+            #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
             Self::Required(_) => f.pad("Required"),
-            #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+            #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
             Self::Wrapper(_) => f.pad("Wrapper"),
         }
     }
 }
 
+/// Source for the base set of root certificates to trust.
+#[allow(missing_copy_implementations)]
+#[derive(Clone, Debug, Default)]
+pub enum CertificateStore {
+    /// Use the default for the TLS backend.
+    ///
+    /// For native-tls, this will use the system certificate store on Windows, the keychain on
+    /// macOS, and OpenSSL directories on Linux (usually `/etc/ssl`).
+    ///
+    /// For rustls, this will also use the system store if the `rustls-native-certs` feature is
+    /// enabled, or will fall back to `webpki-roots`.
+    ///
+    /// The boring-tls backend uses the same logic as OpenSSL on all platforms.
+    #[default]
+    Default,
+    /// Use a hardcoded set of Mozilla roots via the `webpki-roots` crate.
+    ///
+    /// This option is only available in the rustls backend.
+    #[cfg(feature = "rustls-tls")]
+    WebpkiRoots,
+    /// Don't use any system certificates.
+    None,
+}
+
 /// Parameters to use for secure clients
 #[derive(Clone)]
 pub struct TlsParameters {
     pub(crate) connector: InnerTlsParameters,
     /// The domain name which is expected in the TLS certificate from the server
     pub(super) domain: String,
+    #[cfg(feature = "boring-tls")]
+    pub(super) accept_invalid_hostnames: bool,
 }
 
 /// Builder for `TlsParameters`
 #[derive(Debug, Clone)]
 pub struct TlsParametersBuilder {
     domain: String,
+    cert_store: CertificateStore,
     root_certs: Vec<Certificate>,
+    identity: Option<Identity>,
     accept_invalid_hostnames: bool,
     accept_invalid_certs: bool,
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    min_tls_version: TlsVersion,
 }
 
 impl TlsParametersBuilder {
@@ -72,20 +154,38 @@ impl TlsParametersBuilder {
     pub fn new(domain: String) -> Self {
         Self {
             domain,
+            cert_store: CertificateStore::Default,
             root_certs: Vec::new(),
+            identity: None,
             accept_invalid_hostnames: false,
             accept_invalid_certs: false,
+            #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+            min_tls_version: TlsVersion::Tlsv12,
         }
     }
 
+    /// Set the source for the base set of root certificates to trust.
+    pub fn certificate_store(mut self, cert_store: CertificateStore) -> Self {
+        self.cert_store = cert_store;
+        self
+    }
+
     /// Add a custom root certificate
     ///
-    /// Can be used to safely connect to a server using a self signed certificate, for example.
+    /// 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
     }
 
+    /// Add a client certificate
+    ///
+    /// Can be used to configure a client certificate to present to the server.
+    pub fn identify_with(mut self, identity: Identity) -> Self {
+        self.identity = Some(identity);
+        self
+    }
+
     /// Controls whether certificates with an invalid hostname are accepted
     ///
     /// Defaults to `false`.
@@ -97,15 +197,25 @@ impl TlsParametersBuilder {
     /// 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")))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
     pub fn dangerous_accept_invalid_hostnames(mut self, accept_invalid_hostnames: bool) -> Self {
         self.accept_invalid_hostnames = accept_invalid_hostnames;
         self
     }
 
+    /// Controls which minimum TLS version is allowed
+    ///
+    /// Defaults to [`Tlsv12`][TlsVersion::Tlsv12].
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    pub fn set_min_tls_version(mut self, min_tls_version: TlsVersion) -> Self {
+        self.min_tls_version = min_tls_version;
+        self
+    }
+
     /// Controls whether invalid certificates are accepted
     ///
     /// Defaults to `false`.
@@ -127,16 +237,20 @@ impl TlsParametersBuilder {
         self
     }
 
-    /// Creates a new `TlsParameters` using native-tls or rustls
+    /// Creates a new `TlsParameters` using native-tls, boring-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"))))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
     pub fn build(self) -> Result<TlsParameters, Error> {
         #[cfg(feature = "rustls-tls")]
         return self.build_rustls();
-
-        #[cfg(not(feature = "rustls-tls"))]
+        #[cfg(all(not(feature = "rustls-tls"), feature = "native-tls"))]
         return self.build_native();
+        #[cfg(all(not(feature = "rustls-tls"), feature = "boring-tls"))]
+        return self.build_boring();
     }
 
     /// Creates a new `TlsParameters` using native-tls with the provided configuration
@@ -145,17 +259,106 @@ impl TlsParametersBuilder {
     pub fn build_native(self) -> Result<TlsParameters, Error> {
         let mut tls_builder = TlsConnector::builder();
 
+        match self.cert_store {
+            CertificateStore::Default => {}
+            CertificateStore::None => {
+                tls_builder.disable_built_in_roots(true);
+            }
+            #[allow(unreachable_patterns)]
+            other => {
+                return Err(error::tls(format!(
+                    "{other:?} is not supported in native tls"
+                )))
+            }
+        }
         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 min_tls_version = match self.min_tls_version {
+            TlsVersion::Tlsv10 => Protocol::Tlsv10,
+            TlsVersion::Tlsv11 => Protocol::Tlsv11,
+            TlsVersion::Tlsv12 => Protocol::Tlsv12,
+            TlsVersion::Tlsv13 => {
+                return Err(error::tls(
+                    "min tls version Tlsv13 not supported in native tls",
+                ))
+            }
+        };
+
+        tls_builder.min_protocol_version(Some(min_tls_version));
+        if let Some(identity) = self.identity {
+            tls_builder.identity(identity.native_tls);
+        }
+
         let connector = tls_builder.build().map_err(error::tls)?;
         Ok(TlsParameters {
             connector: InnerTlsParameters::NativeTls(connector),
             domain: self.domain,
+            #[cfg(feature = "boring-tls")]
+            accept_invalid_hostnames: self.accept_invalid_hostnames,
+        })
+    }
+
+    /// Creates a new `TlsParameters` using boring-tls with the provided configuration
+    #[cfg(feature = "boring-tls")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "boring-tls")))]
+    pub fn build_boring(self) -> Result<TlsParameters, Error> {
+        use boring::ssl::{SslMethod, SslVerifyMode};
+
+        let mut tls_builder = SslConnector::builder(SslMethod::tls_client()).map_err(error::tls)?;
+
+        if self.accept_invalid_certs {
+            tls_builder.set_verify(SslVerifyMode::NONE);
+        } else {
+            match self.cert_store {
+                CertificateStore::Default => {}
+                CertificateStore::None => {
+                    // Replace the default store with an empty store.
+                    tls_builder
+                        .set_cert_store(X509StoreBuilder::new().map_err(error::tls)?.build());
+                }
+                #[allow(unreachable_patterns)]
+                other => {
+                    return Err(error::tls(format!(
+                        "{other:?} is not supported in boring tls"
+                    )))
+                }
+            }
+
+            let cert_store = tls_builder.cert_store_mut();
+
+            for cert in self.root_certs {
+                cert_store.add_cert(cert.boring_tls).map_err(error::tls)?;
+            }
+        }
+
+        if let Some(identity) = self.identity {
+            tls_builder
+                .set_certificate(identity.boring_tls.0.as_ref())
+                .map_err(error::tls)?;
+            tls_builder
+                .set_private_key(identity.boring_tls.1.as_ref())
+                .map_err(error::tls)?;
+        }
+
+        let min_tls_version = match self.min_tls_version {
+            TlsVersion::Tlsv10 => SslVersion::TLS1,
+            TlsVersion::Tlsv11 => SslVersion::TLS1_1,
+            TlsVersion::Tlsv12 => SslVersion::TLS1_2,
+            TlsVersion::Tlsv13 => SslVersion::TLS1_3,
+        };
+
+        tls_builder
+            .set_min_proto_version(Some(min_tls_version))
+            .map_err(error::tls)?;
+        let connector = tls_builder.build();
+        Ok(TlsParameters {
+            connector: InnerTlsParameters::BoringTls(connector),
+            domain: self.domain,
+            accept_invalid_hostnames: self.accept_invalid_hostnames,
         })
     }
 
@@ -163,45 +366,120 @@ impl TlsParametersBuilder {
     #[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 just_version3 = &[&rustls::version::TLS13];
+        let supported_versions = match self.min_tls_version {
+            TlsVersion::Tlsv10 => {
+                return Err(error::tls("min tls version Tlsv10 not supported in rustls"))
+            }
+            TlsVersion::Tlsv11 => {
+                return Err(error::tls("min tls version Tlsv11 not supported in rustls"))
+            }
+            TlsVersion::Tlsv12 => rustls::ALL_VERSIONS,
+            TlsVersion::Tlsv13 => just_version3,
+        };
 
-        let mut tls = ClientConfig::new();
+        let tls = ClientConfig::builder_with_protocol_versions(supported_versions);
+        let provider = rustls::crypto::CryptoProvider::get_default()
+            .cloned()
+            .unwrap_or_else(|| Arc::new(rustls::crypto::ring::default_provider()));
 
+        // Build TLS config
+        let signature_algorithms = provider.signature_verification_algorithms;
+
+        let mut root_cert_store = RootCertStore::empty();
+
+        #[cfg(feature = "rustls-native-certs")]
+        fn load_native_roots(store: &mut RootCertStore) -> Result<(), Error> {
+            let rustls_native_certs::CertificateResult { certs, errors, .. } =
+                rustls_native_certs::load_native_certs();
+            let errors_len = errors.len();
+
+            let (added, ignored) = store.add_parsable_certificates(certs);
+            #[cfg(feature = "tracing")]
+            tracing::debug!(
+                "loaded platform certs with {errors_len} failing to load, {added} valid and {ignored} ignored (invalid) certs"
+            );
+            Ok(())
+        }
+
+        #[cfg(feature = "rustls-tls")]
+        fn load_webpki_roots(store: &mut RootCertStore) {
+            store.extend(webpki_roots::TLS_SERVER_ROOTS.iter().cloned());
+        }
+
+        match self.cert_store {
+            CertificateStore::Default => {
+                #[cfg(feature = "rustls-native-certs")]
+                load_native_roots(&mut root_cert_store)?;
+                #[cfg(not(feature = "rustls-native-certs"))]
+                load_webpki_roots(&mut root_cert_store);
+            }
+            #[cfg(feature = "rustls-tls")]
+            CertificateStore::WebpkiRoots => {
+                load_webpki_roots(&mut root_cert_store);
+            }
+            CertificateStore::None => {}
+        }
         for cert in self.root_certs {
             for rustls_cert in cert.rustls {
-                tls.root_store.add(&rustls_cert).map_err(error::tls)?;
+                root_cert_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);
+        let tls = if self.accept_invalid_certs || self.accept_invalid_hostnames {
+            let verifier = InvalidCertsVerifier {
+                ignore_invalid_hostnames: self.accept_invalid_hostnames,
+                ignore_invalid_certs: self.accept_invalid_certs,
+                roots: root_cert_store,
+                signature_algorithms,
+            };
+            tls.dangerous()
+                .with_custom_certificate_verifier(Arc::new(verifier))
+        } else {
+            tls.with_root_certificates(root_cert_store)
+        };
+
+        let tls = if let Some(identity) = self.identity {
+            let (client_certificates, private_key) = identity.rustls_tls;
+            tls.with_client_auth_cert(client_certificates, private_key)
+                .map_err(error::tls)?
+        } else {
+            tls.with_no_client_auth()
+        };
+
         Ok(TlsParameters {
             connector: InnerTlsParameters::RustlsTls(Arc::new(tls)),
             domain: self.domain,
+            #[cfg(feature = "boring-tls")]
+            accept_invalid_hostnames: self.accept_invalid_hostnames,
         })
     }
 }
 
 #[derive(Clone)]
+#[allow(clippy::enum_variant_names)]
 pub enum InnerTlsParameters {
     #[cfg(feature = "native-tls")]
     NativeTls(TlsConnector),
     #[cfg(feature = "rustls-tls")]
     RustlsTls(Arc<ClientConfig>),
+    #[cfg(feature = "boring-tls")]
+    BoringTls(SslConnector),
 }
 
 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"))))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
     pub fn new(domain: String) -> Result<Self, Error> {
         TlsParametersBuilder::new(domain).build()
     }
 
+    /// Creates a new `TlsParameters` builder
     pub fn builder(domain: String) -> TlsParametersBuilder {
         TlsParametersBuilder::new(domain)
     }
@@ -220,33 +498,47 @@ impl TlsParameters {
         TlsParametersBuilder::new(domain).build_rustls()
     }
 
+    /// Creates a new `TlsParameters` using boring
+    #[cfg(feature = "boring-tls")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "boring-tls")))]
+    pub fn new_boring(domain: String) -> Result<Self, Error> {
+        TlsParametersBuilder::new(domain).build_boring()
+    }
+
     pub fn domain(&self) -> &str {
         &self.domain
     }
 }
 
-/// A client certificate that can be used with [`TlsParametersBuilder::add_root_certificate`]
+/// A 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>,
+    rustls: Vec<CertificateDer<'static>>,
+    #[cfg(feature = "boring-tls")]
+    boring_tls: boring::x509::X509,
 }
 
-#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+#[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-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)?;
 
+        #[cfg(feature = "boring-tls")]
+        let boring_tls_cert = boring::x509::X509::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)],
+            rustls: vec![der.into()],
+            #[cfg(feature = "boring-tls")]
+            boring_tls: boring_tls_cert,
         })
     }
 
@@ -255,13 +547,17 @@ impl Certificate {
         #[cfg(feature = "native-tls")]
         let native_tls_cert = native_tls::Certificate::from_pem(pem).map_err(error::tls)?;
 
+        #[cfg(feature = "boring-tls")]
+        let boring_tls_cert = boring::x509::X509::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"))?
+            rustls_pemfile::certs(&mut pem)
+                .collect::<io::Result<Vec<_>>>()
+                .map_err(|_| error::tls("invalid certificates"))?
         };
 
         Ok(Self {
@@ -269,6 +565,8 @@ impl Certificate {
             native_tls: native_tls_cert,
             #[cfg(feature = "rustls-tls")]
             rustls: rustls_cert,
+            #[cfg(feature = "boring-tls")]
+            boring_tls: boring_tls_cert,
         })
     }
 }
@@ -279,18 +577,143 @@ impl Debug for Certificate {
     }
 }
 
+/// An identity that can be used with [`TlsParametersBuilder::identify_with`]
+#[allow(missing_copy_implementations)]
+pub struct Identity {
+    #[cfg(feature = "native-tls")]
+    native_tls: native_tls::Identity,
+    #[cfg(feature = "rustls-tls")]
+    rustls_tls: (Vec<CertificateDer<'static>>, PrivateKeyDer<'static>),
+    #[cfg(feature = "boring-tls")]
+    boring_tls: (boring::x509::X509, PKey<boring::pkey::Private>),
+}
+
+impl Debug for Identity {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Identity").finish()
+    }
+}
+
+impl Clone for Identity {
+    fn clone(&self) -> Self {
+        Identity {
+            #[cfg(feature = "native-tls")]
+            native_tls: self.native_tls.clone(),
+            #[cfg(feature = "rustls-tls")]
+            rustls_tls: (self.rustls_tls.0.clone(), self.rustls_tls.1.clone_key()),
+            #[cfg(feature = "boring-tls")]
+            boring_tls: (self.boring_tls.0.clone(), self.boring_tls.1.clone()),
+        }
+    }
+}
+
+#[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+impl Identity {
+    pub fn from_pem(pem: &[u8], key: &[u8]) -> Result<Self, Error> {
+        Ok(Self {
+            #[cfg(feature = "native-tls")]
+            native_tls: Identity::from_pem_native_tls(pem, key)?,
+            #[cfg(feature = "rustls-tls")]
+            rustls_tls: Identity::from_pem_rustls_tls(pem, key)?,
+            #[cfg(feature = "boring-tls")]
+            boring_tls: Identity::from_pem_boring_tls(pem, key)?,
+        })
+    }
+
+    #[cfg(feature = "native-tls")]
+    fn from_pem_native_tls(pem: &[u8], key: &[u8]) -> Result<native_tls::Identity, Error> {
+        native_tls::Identity::from_pkcs8(pem, key).map_err(error::tls)
+    }
+
+    #[cfg(feature = "rustls-tls")]
+    fn from_pem_rustls_tls(
+        pem: &[u8],
+        key: &[u8],
+    ) -> Result<(Vec<CertificateDer<'static>>, PrivateKeyDer<'static>), Error> {
+        let mut key = key;
+        let key = rustls_pemfile::private_key(&mut key).unwrap().unwrap();
+        Ok((vec![pem.to_owned().into()], key))
+    }
+
+    #[cfg(feature = "boring-tls")]
+    fn from_pem_boring_tls(
+        pem: &[u8],
+        key: &[u8],
+    ) -> Result<(boring::x509::X509, PKey<boring::pkey::Private>), Error> {
+        let cert = boring::x509::X509::from_pem(pem).map_err(error::tls)?;
+        let key = boring::pkey::PKey::private_key_from_pem(key).map_err(error::tls)?;
+        Ok((cert, key))
+    }
+}
+
 #[cfg(feature = "rustls-tls")]
-struct InvalidCertsVerifier;
+#[derive(Debug)]
+struct InvalidCertsVerifier {
+    ignore_invalid_hostnames: bool,
+    ignore_invalid_certs: bool,
+    roots: RootCertStore,
+    signature_algorithms: WebPkiSupportedAlgorithms,
+}
 
 #[cfg(feature = "rustls-tls")]
 impl ServerCertVerifier for InvalidCertsVerifier {
     fn verify_server_cert(
         &self,
-        _roots: &RootCertStore,
-        _presented_certs: &[rustls::Certificate],
-        _dns_name: DNSNameRef<'_>,
+        end_entity: &CertificateDer<'_>,
+        intermediates: &[CertificateDer<'_>],
+        server_name: &ServerName<'_>,
         _ocsp_response: &[u8],
-    ) -> Result<ServerCertVerified, TLSError> {
+        now: UnixTime,
+    ) -> Result<ServerCertVerified, TlsError> {
+        let cert = ParsedCertificate::try_from(end_entity)?;
+
+        if !self.ignore_invalid_certs {
+            rustls::client::verify_server_cert_signed_by_trust_anchor(
+                &cert,
+                &self.roots,
+                intermediates,
+                now,
+                self.signature_algorithms.all,
+            )?;
+        }
+
+        if !self.ignore_invalid_hostnames {
+            rustls::client::verify_server_name(&cert, server_name)?;
+        }
         Ok(ServerCertVerified::assertion())
     }
+
+    fn verify_tls12_signature(
+        &self,
+        message: &[u8],
+        cert: &CertificateDer<'_>,
+        dss: &DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, TlsError> {
+        verify_tls12_signature(
+            message,
+            cert,
+            dss,
+            &rustls::crypto::ring::default_provider().signature_verification_algorithms,
+        )
+    }
+
+    fn verify_tls13_signature(
+        &self,
+        message: &[u8],
+        cert: &CertificateDer<'_>,
+        dss: &DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, TlsError> {
+        verify_tls13_signature(
+            message,
+            cert,
+            dss,
+            &rustls::crypto::ring::default_provider().signature_verification_algorithms,
+        )
+    }
+
+    fn supported_verify_schemes(&self) -> Vec<SignatureScheme> {
+        rustls::crypto::ring::default_provider()
+            .signature_verification_algorithms
+            .supported_schemes()
+    }
 }

src/transport/smtp/commands.rs

@@ -1,5 +1,7 @@
 //! SMTP commands
 
+use std::fmt::{self, Display, Formatter};
+
 use crate::{
     address::Address,
     transport::smtp::{
@@ -9,10 +11,9 @@ use crate::{
         response::Response,
     },
 };
-use std::fmt::{self, Display, Formatter};
 
 /// EHLO command
-#[derive(PartialEq, Clone, Debug)]
+#[derive(PartialEq, Eq, Clone, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Ehlo {
     client_id: ClientId,
@@ -32,7 +33,7 @@ impl Ehlo {
 }
 
 /// STARTTLS command
-#[derive(PartialEq, Clone, Debug, Copy)]
+#[derive(PartialEq, Eq, Clone, Debug, Copy)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Starttls;
 
@@ -43,7 +44,7 @@ impl Display for Starttls {
 }
 
 /// MAIL command
-#[derive(PartialEq, Clone, Debug)]
+#[derive(PartialEq, Eq, Clone, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Mail {
     sender: Option<Address>,
@@ -58,7 +59,7 @@ impl Display for Mail {
             self.sender.as_ref().map_or("", |s| s.as_ref())
         )?;
         for parameter in &self.parameters {
-            write!(f, " {}", parameter)?;
+            write!(f, " {parameter}")?;
         }
         f.write_str("\r\n")
     }
@@ -72,7 +73,7 @@ impl Mail {
 }
 
 /// RCPT command
-#[derive(PartialEq, Clone, Debug)]
+#[derive(PartialEq, Eq, Clone, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Rcpt {
     recipient: Address,
@@ -83,7 +84,7 @@ impl Display for Rcpt {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "RCPT TO:<{}>", self.recipient)?;
         for parameter in &self.parameters {
-            write!(f, " {}", parameter)?;
+            write!(f, " {parameter}")?;
         }
         f.write_str("\r\n")
     }
@@ -100,7 +101,7 @@ impl Rcpt {
 }
 
 /// DATA command
-#[derive(PartialEq, Clone, Debug, Copy)]
+#[derive(PartialEq, Eq, Clone, Debug, Copy)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Data;
 
@@ -111,7 +112,7 @@ impl Display for Data {
 }
 
 /// QUIT command
-#[derive(PartialEq, Clone, Debug, Copy)]
+#[derive(PartialEq, Eq, Clone, Debug, Copy)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Quit;
 
@@ -122,7 +123,7 @@ impl Display for Quit {
 }
 
 /// NOOP command
-#[derive(PartialEq, Clone, Debug, Copy)]
+#[derive(PartialEq, Eq, Clone, Debug, Copy)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Noop;
 
@@ -133,7 +134,7 @@ impl Display for Noop {
 }
 
 /// HELP command
-#[derive(PartialEq, Clone, Debug)]
+#[derive(PartialEq, Eq, Clone, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Help {
     argument: Option<String>,
@@ -143,7 +144,7 @@ impl Display for Help {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.write_str("HELP")?;
         if let Some(argument) = &self.argument {
-            write!(f, " {}", argument)?;
+            write!(f, " {argument}")?;
         }
         f.write_str("\r\n")
     }
@@ -157,7 +158,7 @@ impl Help {
 }
 
 /// VRFY command
-#[derive(PartialEq, Clone, Debug)]
+#[derive(PartialEq, Eq, Clone, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Vrfy {
     argument: String,
@@ -177,7 +178,7 @@ impl Vrfy {
 }
 
 /// EXPN command
-#[derive(PartialEq, Clone, Debug)]
+#[derive(PartialEq, Eq, Clone, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Expn {
     argument: String,
@@ -197,7 +198,7 @@ impl Expn {
 }
 
 /// RSET command
-#[derive(PartialEq, Clone, Debug, Copy)]
+#[derive(PartialEq, Eq, Clone, Debug, Copy)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Rset;
 
@@ -208,7 +209,7 @@ impl Display for Rset {
 }
 
 /// AUTH command
-#[derive(PartialEq, Clone, Debug)]
+#[derive(PartialEq, Eq, Clone, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Auth {
     mechanism: Mechanism,
@@ -219,7 +220,7 @@ pub struct Auth {
 
 impl Display for Auth {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        let encoded_response = self.response.as_ref().map(base64::encode);
+        let encoded_response = self.response.as_ref().map(crate::base64::encode);
 
         if self.mechanism.supports_initial_response() {
             write!(f, "AUTH {} {}", self.mechanism, encoded_response.unwrap())?;
@@ -270,7 +271,7 @@ impl Auth {
         #[cfg(feature = "tracing")]
         tracing::debug!("auth encoded challenge: {}", encoded_challenge);
 
-        let decoded_base64 = base64::decode(&encoded_challenge).map_err(error::response)?;
+        let decoded_base64 = crate::base64::decode(encoded_challenge).map_err(error::response)?;
         let decoded_challenge = String::from_utf8(decoded_base64).map_err(error::response)?;
         #[cfg(feature = "tracing")]
         tracing::debug!("auth decoded challenge: {}", decoded_challenge);
@@ -288,21 +289,22 @@ impl Auth {
 
 #[cfg(test)]
 mod test {
+    use std::str::FromStr;
+
     use super::*;
     use crate::transport::smtp::extension::MailBodyParameter;
-    use std::str::FromStr;
 
     #[test]
     fn test_display() {
-        let id = ClientId::Domain("localhost".to_string());
+        let id = ClientId::Domain("localhost".to_owned());
         let email = Address::from_str("test@example.com").unwrap();
         let mail_parameter = MailParameter::Other {
-            keyword: "TEST".to_string(),
-            value: Some("value".to_string()),
+            keyword: "TEST".to_owned(),
+            value: Some("value".to_owned()),
         };
         let rcpt_parameter = RcptParameter::Other {
-            keyword: "TEST".to_string(),
-            value: Some("value".to_string()),
+            keyword: "TEST".to_owned(),
+            value: Some("value".to_owned()),
         };
         assert_eq!(format!("{}", Ehlo::new(id)), "EHLO localhost\r\n");
         assert_eq!(
@@ -339,24 +341,18 @@ mod test {
             format!("{}", Rcpt::new(email, vec![rcpt_parameter])),
             "RCPT TO:<test@example.com> TEST=value\r\n"
         );
-        assert_eq!(format!("{}", Quit), "QUIT\r\n");
-        assert_eq!(format!("{}", Data), "DATA\r\n");
-        assert_eq!(format!("{}", Noop), "NOOP\r\n");
+        assert_eq!(format!("{Quit}"), "QUIT\r\n");
+        assert_eq!(format!("{Data}"), "DATA\r\n");
+        assert_eq!(format!("{Noop}"), "NOOP\r\n");
         assert_eq!(format!("{}", Help::new(None)), "HELP\r\n");
         assert_eq!(
-            format!("{}", Help::new(Some("test".to_string()))),
+            format!("{}", Help::new(Some("test".to_owned()))),
             "HELP test\r\n"
         );
-        assert_eq!(
-            format!("{}", Vrfy::new("test".to_string())),
-            "VRFY test\r\n"
-        );
-        assert_eq!(
-            format!("{}", Expn::new("test".to_string())),
-            "EXPN test\r\n"
-        );
-        assert_eq!(format!("{}", Rset), "RSET\r\n");
-        let credentials = Credentials::new("user".to_string(), "password".to_string());
+        assert_eq!(format!("{}", Vrfy::new("test".to_owned())), "VRFY test\r\n");
+        assert_eq!(format!("{}", Expn::new("test".to_owned())), "EXPN test\r\n");
+        assert_eq!(format!("{Rset}"), "RSET\r\n");
+        let credentials = Credentials::new("user".to_owned(), "password".to_owned());
         assert_eq!(
             format!(
                 "{}",

src/transport/smtp/connection_url.rs

@@ -0,0 +1,129 @@
+use url::Url;
+
+#[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+use super::client::{Tls, TlsParameters};
+#[cfg(any(feature = "tokio1", feature = "async-std1"))]
+use super::AsyncSmtpTransportBuilder;
+use super::{
+    authentication::Credentials, error, extension::ClientId, Error, SmtpTransportBuilder,
+    SMTP_PORT, SUBMISSIONS_PORT, SUBMISSION_PORT,
+};
+
+pub(crate) trait TransportBuilder {
+    fn new<T: Into<String>>(server: T) -> Self;
+    fn tls(self, tls: super::Tls) -> Self;
+    fn port(self, port: u16) -> Self;
+    fn credentials(self, credentials: Credentials) -> Self;
+    fn hello_name(self, name: ClientId) -> Self;
+}
+
+impl TransportBuilder for SmtpTransportBuilder {
+    fn new<T: Into<String>>(server: T) -> Self {
+        Self::new(server)
+    }
+
+    fn tls(self, tls: super::Tls) -> Self {
+        self.tls(tls)
+    }
+
+    fn port(self, port: u16) -> Self {
+        self.port(port)
+    }
+
+    fn credentials(self, credentials: Credentials) -> Self {
+        self.credentials(credentials)
+    }
+
+    fn hello_name(self, name: ClientId) -> Self {
+        self.hello_name(name)
+    }
+}
+
+#[cfg(any(feature = "tokio1", feature = "async-std1"))]
+impl TransportBuilder for AsyncSmtpTransportBuilder {
+    fn new<T: Into<String>>(server: T) -> Self {
+        Self::new(server)
+    }
+
+    fn tls(self, tls: super::Tls) -> Self {
+        self.tls(tls)
+    }
+
+    fn port(self, port: u16) -> Self {
+        self.port(port)
+    }
+
+    fn credentials(self, credentials: Credentials) -> Self {
+        self.credentials(credentials)
+    }
+
+    fn hello_name(self, name: ClientId) -> Self {
+        self.hello_name(name)
+    }
+}
+
+/// Create a new SmtpTransportBuilder or AsyncSmtpTransportBuilder from a connection URL
+pub(crate) fn from_connection_url<B: TransportBuilder>(connection_url: &str) -> Result<B, Error> {
+    let connection_url = Url::parse(connection_url).map_err(error::connection)?;
+    let tls: Option<String> = connection_url
+        .query_pairs()
+        .find(|(k, _)| k == "tls")
+        .map(|(_, v)| v.to_string());
+
+    let host = connection_url
+        .host_str()
+        .ok_or_else(|| error::connection("smtp host undefined"))?;
+
+    let mut builder = B::new(host);
+
+    match (connection_url.scheme(), tls.as_deref()) {
+        ("smtp", None) => {
+            builder = builder.port(connection_url.port().unwrap_or(SMTP_PORT));
+        }
+        #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+        ("smtp", Some("required")) => {
+            builder = builder
+                .port(connection_url.port().unwrap_or(SUBMISSION_PORT))
+                .tls(Tls::Required(TlsParameters::new(host.into())?))
+        }
+        #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+        ("smtp", Some("opportunistic")) => {
+            builder = builder
+                .port(connection_url.port().unwrap_or(SUBMISSION_PORT))
+                .tls(Tls::Opportunistic(TlsParameters::new(host.into())?))
+        }
+        #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+        ("smtps", _) => {
+            builder = builder
+                .port(connection_url.port().unwrap_or(SUBMISSIONS_PORT))
+                .tls(Tls::Wrapper(TlsParameters::new(host.into())?))
+        }
+        (scheme, tls) => {
+            return Err(error::connection(format!(
+                "Unknown scheme '{scheme}' or tls parameter '{tls:?}', note that a transport with TLS requires one of the TLS features"
+            )))
+        }
+    };
+
+    // use the path segment of the URL as name in the name in the HELO / EHLO command
+    if connection_url.path().len() > 1 {
+        let name = connection_url.path().trim_matches('/').to_owned();
+        builder = builder.hello_name(ClientId::Domain(name));
+    }
+
+    if let Some(password) = connection_url.password() {
+        let percent_decode = |s: &str| {
+            percent_encoding::percent_decode_str(s)
+                .decode_utf8()
+                .map(|cow| cow.into_owned())
+                .map_err(error::connection)
+        };
+        let credentials = Credentials::new(
+            percent_decode(connection_url.username())?,
+            percent_decode(password)?,
+        );
+        builder = builder.credentials(credentials);
+    }
+
+    Ok(builder)
+}

src/transport/smtp/error.rs

@@ -1,10 +1,11 @@
 //! Error and result type for SMTP clients
 
+use std::{error::Error as StdError, fmt};
+
 use crate::{
     transport::smtp::response::{Code, Severity},
     BoxError,
 };
-use std::{error::Error as StdError, fmt};
 
 // Inspired by https://github.com/seanmonstar/reqwest/blob/a8566383168c0ef06c21f38cbc9213af6ff6db31/src/error.rs
 
@@ -67,8 +68,11 @@ impl Error {
     }
 
     /// 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"))))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
     pub fn is_tls(&self) -> bool {
         matches!(self.inner.kind, Kind::Tls)
     }
@@ -101,8 +105,11 @@ pub(crate) enum Kind {
     /// Underlying network i/o error
     Network,
     /// TLS error
-    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
     Tls,
 }
 
@@ -112,7 +119,7 @@ impl fmt::Debug for Error {
 
         builder.field("kind", &self.inner.kind);
 
-        if let Some(ref source) = self.inner.source {
+        if let Some(source) = &self.inner.source {
             builder.field("source", source);
         }
 
@@ -122,23 +129,23 @@ impl fmt::Debug for Error {
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self.inner.kind {
+        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"))]
+            #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
             Kind::Tls => f.write_str("tls error")?,
-            Kind::Transient(ref code) => {
-                write!(f, "transient error ({})", code)?;
+            Kind::Transient(code) => {
+                write!(f, "transient error ({code})")?;
             }
-            Kind::Permanent(ref code) => {
-                write!(f, "permanent error ({})", code)?;
+            Kind::Permanent(code) => {
+                write!(f, "permanent error ({code})")?;
             }
         };
 
-        if let Some(ref e) = self.inner.source {
-            write!(f, ": {}", e)?;
+        if let Some(e) = &self.inner.source {
+            write!(f, ": {e}")?;
         }
 
         Ok(())
@@ -154,10 +161,10 @@ impl StdError for Error {
     }
 }
 
-pub(crate) fn code(c: Code) -> Error {
+pub(crate) fn code(c: Code, s: Option<String>) -> Error {
     match c.severity {
-        Severity::TransientNegativeCompletion => Error::new::<Error>(Kind::Transient(c), None),
-        Severity::PermanentNegativeCompletion => Error::new::<Error>(Kind::Permanent(c), None),
+        Severity::TransientNegativeCompletion => Error::new(Kind::Transient(c), s),
+        Severity::PermanentNegativeCompletion => Error::new(Kind::Permanent(c), s),
         _ => client("Unknown error code"),
     }
 }
@@ -178,7 +185,7 @@ pub(crate) fn connection<E: Into<BoxError>>(e: E) -> Error {
     Error::new(Kind::Connection, Some(e))
 }
 
-#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+#[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
 pub(crate) fn tls<E: Into<BoxError>>(e: E) -> Error {
     Error::new(Kind::Tls, Some(e))
 }

src/transport/smtp/extension.rs

@@ -1,17 +1,17 @@
 //! ESMTP features
 
+use std::{
+    collections::HashSet,
+    fmt::{self, Display, Formatter},
+    net::{Ipv4Addr, Ipv6Addr},
+};
+
 use crate::transport::smtp::{
     authentication::Mechanism,
     error::{self, Error},
     response::Response,
     util::XText,
 };
-use std::{
-    collections::HashSet,
-    fmt::{self, Display, Formatter},
-    net::{Ipv4Addr, Ipv6Addr},
-    result::Result,
-};
 
 /// Client identifier, the parameter to `EHLO`
 #[derive(PartialEq, Eq, Clone, Debug)]
@@ -52,10 +52,10 @@ impl Default for ClientId {
 
 impl Display for ClientId {
     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),
-            Self::Ipv6(ref value) => write!(f, "[IPv6:{}]", value),
+        match self {
+            Self::Domain(value) => f.write_str(value),
+            Self::Ipv4(value) => write!(f, "[{value}]"),
+            Self::Ipv6(value) => write!(f, "[IPv6:{value}]"),
         }
     }
 }
@@ -72,6 +72,7 @@ impl ClientId {
 /// Supported ESMTP keywords
 #[derive(PartialEq, Eq, Hash, Copy, Clone, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[non_exhaustive]
 pub enum Extension {
     /// 8BITMIME keyword
     ///
@@ -91,11 +92,11 @@ pub enum Extension {
 
 impl Display for Extension {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match *self {
+        match self {
             Extension::EightBitMime => f.write_str("8BITMIME"),
             Extension::SmtpUtfEight => f.write_str("SMTPUTF8"),
             Extension::StartTls => f.write_str("STARTTLS"),
-            Extension::Authentication(ref mechanism) => write!(f, "AUTH {}", mechanism),
+            Extension::Authentication(mechanism) => write!(f, "AUTH {mechanism}"),
         }
     }
 }
@@ -107,17 +108,17 @@ pub struct ServerInfo {
     /// Server name
     ///
     /// The name given in the server banner
-    pub name: String,
+    name: String,
     /// ESMTP features supported by the server
     ///
     /// It contains the features supported by the server and known by the `Extension` module.
-    pub features: HashSet<Extension>,
+    features: HashSet<Extension>,
 }
 
 impl Display for ServerInfo {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         let features = if self.features.is_empty() {
-            "no supported features".to_string()
+            "no supported features".to_owned()
         } else {
             format!("{:?}", self.features)
         };
@@ -135,7 +136,7 @@ impl ServerInfo {
 
         let mut features: HashSet<Extension> = HashSet::new();
 
-        for line in response.message.as_slice() {
+        for line in response.message() {
             if line.is_empty() {
                 continue;
             }
@@ -172,7 +173,7 @@ impl ServerInfo {
         }
 
         Ok(ServerInfo {
-            name: name.to_string(),
+            name: name.to_owned(),
             features,
         })
     }
@@ -188,7 +189,7 @@ impl ServerInfo {
             .contains(&Extension::Authentication(mechanism))
     }
 
-    /// Gets a compatible mechanism from list
+    /// Gets a compatible mechanism from a list
     pub fn get_auth_mechanism(&self, mechanisms: &[Mechanism]) -> Option<Mechanism> {
         for mechanism in mechanisms {
             if self.supports_auth_mechanism(*mechanism) {
@@ -197,6 +198,11 @@ impl ServerInfo {
         }
         None
     }
+
+    /// The name given in the server banner
+    pub fn name(&self) -> &str {
+        self.name.as_ref()
+    }
 }
 
 /// A `MAIL FROM` extension parameter
@@ -220,16 +226,16 @@ pub enum MailParameter {
 
 impl Display for MailParameter {
     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),
+        match self {
+            MailParameter::Body(value) => write!(f, "BODY={value}"),
+            MailParameter::Size(size) => write!(f, "SIZE={size}"),
             MailParameter::SmtpUtfEight => f.write_str("SMTPUTF8"),
             MailParameter::Other {
-                ref keyword,
-                value: Some(ref value),
+                keyword,
+                value: Some(value),
             } => write!(f, "{}={}", keyword, XText(value)),
             MailParameter::Other {
-                ref keyword,
+                keyword,
                 value: None,
             } => f.write_str(keyword),
         }
@@ -270,13 +276,13 @@ pub enum RcptParameter {
 
 impl Display for RcptParameter {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match *self {
+        match &self {
             RcptParameter::Other {
-                ref keyword,
-                value: Some(ref value),
-            } => write!(f, "{}={}", keyword, XText(value)),
+                keyword,
+                value: Some(value),
+            } => write!(f, "{keyword}={}", XText(value)),
             RcptParameter::Other {
-                ref keyword,
+                keyword,
                 value: None,
             } => f.write_str(keyword),
         }
@@ -285,32 +291,27 @@ impl Display for RcptParameter {
 
 #[cfg(test)]
 mod test {
-
     use super::*;
-    use crate::transport::smtp::{
-        authentication::Mechanism,
-        response::{Category, Code, Detail, Response, Severity},
-    };
-    use std::collections::HashSet;
+    use crate::transport::smtp::response::{Category, Code, Detail, Severity};
 
     #[test]
     fn test_clientid_fmt() {
         assert_eq!(
-            format!("{}", ClientId::Domain("test".to_string())),
-            "test".to_string()
+            format!("{}", ClientId::Domain("test".to_owned())),
+            "test".to_owned()
         );
-        assert_eq!(format!("{}", LOCALHOST_CLIENT), "[127.0.0.1]".to_string());
+        assert_eq!(format!("{LOCALHOST_CLIENT}"), "[127.0.0.1]".to_owned());
     }
 
     #[test]
     fn test_extension_fmt() {
         assert_eq!(
             format!("{}", Extension::EightBitMime),
-            "8BITMIME".to_string()
+            "8BITMIME".to_owned()
         );
         assert_eq!(
             format!("{}", Extension::Authentication(Mechanism::Plain)),
-            "AUTH PLAIN".to_string()
+            "AUTH PLAIN".to_owned()
         );
     }
 
@@ -323,11 +324,11 @@ mod test {
             format!(
                 "{}",
                 ServerInfo {
-                    name: "name".to_string(),
+                    name: "name".to_owned(),
                     features: eightbitmime,
                 }
             ),
-            "name with {EightBitMime}".to_string()
+            "name with {EightBitMime}".to_owned()
         );
 
         let empty = HashSet::new();
@@ -336,11 +337,11 @@ mod test {
             format!(
                 "{}",
                 ServerInfo {
-                    name: "name".to_string(),
+                    name: "name".to_owned(),
                     features: empty,
                 }
             ),
-            "name with no supported features".to_string()
+            "name with no supported features".to_owned()
         );
 
         let mut plain = HashSet::new();
@@ -350,11 +351,11 @@ mod test {
             format!(
                 "{}",
                 ServerInfo {
-                    name: "name".to_string(),
+                    name: "name".to_owned(),
                     features: plain,
                 }
             ),
-            "name with {Authentication(Plain)}".to_string()
+            "name with {Authentication(Plain)}".to_owned()
         );
     }
 
@@ -366,18 +367,14 @@ mod test {
                 Category::Unspecified4,
                 Detail::One,
             ),
-            vec![
-                "me".to_string(),
-                "8BITMIME".to_string(),
-                "SIZE 42".to_string(),
-            ],
+            vec!["me".to_owned(), "8BITMIME".to_owned(), "SIZE 42".to_owned()],
         );
 
         let mut features = HashSet::new();
         assert!(features.insert(Extension::EightBitMime));
 
         let server_info = ServerInfo {
-            name: "me".to_string(),
+            name: "me".to_owned(),
             features,
         };
 
@@ -393,10 +390,10 @@ mod test {
                 Detail::One,
             ),
             vec![
-                "me".to_string(),
-                "AUTH PLAIN CRAM-MD5 XOAUTH2 OTHER".to_string(),
-                "8BITMIME".to_string(),
-                "SIZE 42".to_string(),
+                "me".to_owned(),
+                "AUTH PLAIN CRAM-MD5 XOAUTH2 OTHER".to_owned(),
+                "8BITMIME".to_owned(),
+                "SIZE 42".to_owned(),
             ],
         );
 
@@ -406,7 +403,7 @@ mod test {
         assert!(features2.insert(Extension::Authentication(Mechanism::Xoauth2),));
 
         let server_info2 = ServerInfo {
-            name: "me".to_string(),
+            name: "me".to_owned(),
             features: features2,
         };
 

src/transport/smtp/mod.rs

@@ -33,7 +33,7 @@
 //! ```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};
+//! use lettre::{Message, SmtpTransport, Transport};
 //!
 //! let email = Message::builder()
 //!     .from("NoBody <nobody@domain.tld>".parse()?)
@@ -43,8 +43,7 @@
 //!     .body(String::from("Be happy!"))?;
 //!
 //! // Create TLS transport on port 465
-//! let sender = SmtpTransport::relay("smtp.example.com")?
-//!     .build();
+//! let sender = SmtpTransport::relay("smtp.example.com")?.build();
 //! // Send the email via remote relay
 //! let result = sender.send(&email);
 //! assert!(result.is_ok());
@@ -59,7 +58,13 @@
 //! ```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}}};
+//! use lettre::{
+//!     transport::smtp::{
+//!         authentication::{Credentials, Mechanism},
+//!         PoolConfig,
+//!     },
+//!     Message, SmtpTransport, Transport,
+//! };
 //!
 //! let email = Message::builder()
 //!     .from("NoBody <nobody@domain.tld>".parse()?)
@@ -71,11 +76,14 @@
 //! // 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()))
+//!     .credentials(Credentials::new(
+//!         "username".to_owned(),
+//!         "password".to_owned(),
+//!     ))
 //!     // Configure expected authentication mechanism
 //!     .authentication(vec![Mechanism::Plain])
 //!     // Connection pool settings
-//!     .pool_config( PoolConfig::new().max_size(20))
+//!     .pool_config(PoolConfig::new().max_size(20))
 //!     .build();
 //!
 //! // Send the email via remote relay
@@ -90,7 +98,10 @@
 //! ```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}};
+//! use lettre::{
+//!     transport::smtp::client::{Tls, TlsParameters},
+//!     Message, SmtpTransport, Transport,
+//! };
 //!
 //! let email = Message::builder()
 //!     .from("NoBody <nobody@domain.tld>".parse()?)
@@ -100,8 +111,9 @@
 //!     .body(String::from("Be happy!"))?;
 //!
 //! // Custom TLS configuration
-//! let tls = TlsParameters::builder("smtp.example.com".to_string())
-//!           .dangerous_accept_invalid_certs(true).build()?;
+//! let tls = TlsParameters::builder("smtp.example.com".to_owned())
+//!     .dangerous_accept_invalid_certs(true)
+//!     .build()?;
 //!
 //! // Create TLS transport on port 465
 //! let sender = SmtpTransport::relay("smtp.example.com")?
@@ -116,17 +128,19 @@
 //! # }
 //! ```
 
+use std::time::Duration;
+
+use client::Tls;
+
 #[cfg(any(feature = "tokio1", feature = "async-std1"))]
 pub use self::async_transport::{AsyncSmtpTransport, AsyncSmtpTransportBuilder};
-#[cfg(feature = "r2d2")]
+#[cfg(feature = "pool")]
 pub use self::pool::PoolConfig;
-#[cfg(feature = "r2d2")]
-pub(crate) use self::transport::SmtpClient;
 pub use self::{
     error::Error,
     transport::{SmtpTransport, SmtpTransportBuilder},
 };
-#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+#[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
 use crate::transport::smtp::client::TlsParameters;
 use crate::transport::smtp::{
     authentication::{Credentials, Mechanism, DEFAULT_MECHANISMS},
@@ -134,21 +148,20 @@ use crate::transport::smtp::{
     extension::ClientId,
     response::Response,
 };
-use client::Tls;
-use std::time::Duration;
 
 #[cfg(any(feature = "tokio1", feature = "async-std1"))]
 mod async_transport;
 pub mod authentication;
 pub mod client;
 pub mod commands;
+mod connection_url;
 mod error;
 pub mod extension;
-#[cfg(feature = "r2d2")]
+#[cfg(feature = "pool")]
 mod pool;
 pub mod response;
 mod transport;
-pub mod util;
+pub(super) mod util;
 
 // Registered port numbers:
 // https://www.iana.
@@ -164,7 +177,7 @@ pub const SUBMISSION_PORT: u16 = 587;
 pub const SUBMISSIONS_PORT: u16 = 465;
 
 /// Default timeout
-pub const DEFAULT_TIMEOUT: Duration = Duration::from_secs(60);
+const DEFAULT_TIMEOUT: Duration = Duration::from_secs(60);
 
 #[derive(Debug, Clone)]
 struct SmtpInfo {
@@ -188,7 +201,7 @@ struct SmtpInfo {
 impl Default for SmtpInfo {
     fn default() -> Self {
         Self {
-            server: "localhost".to_string(),
+            server: "localhost".to_owned(),
             port: SMTP_PORT,
             hello_name: ClientId::default(),
             credentials: None,

src/transport/smtp/pool.rs

@@ -1,111 +0,0 @@
-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),
-        }
-    }
-}
-
-impl ManageConnection for SmtpClient {
-    type Connection = SmtpConnection;
-    type Error = Error;
-
-    fn connect(&self) -> Result<Self::Connection, Error> {
-        self.connection()
-    }
-
-    fn is_valid(&self, conn: &mut Self::Connection) -> Result<(), Error> {
-        if conn.test_connected() {
-            return Ok(());
-        }
-        Err(error::network("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/pool/async_impl.rs

@@ -0,0 +1,300 @@
+use std::{
+    fmt::{self, Debug},
+    mem,
+    ops::{Deref, DerefMut},
+    sync::{Arc, OnceLock},
+    time::{Duration, Instant},
+};
+
+use futures_util::{
+    lock::Mutex,
+    stream::{self, StreamExt},
+};
+
+use super::{
+    super::{client::AsyncSmtpConnection, Error},
+    PoolConfig,
+};
+use crate::{executor::SpawnHandle, transport::smtp::async_transport::AsyncSmtpClient, Executor};
+
+pub struct Pool<E: Executor> {
+    config: PoolConfig,
+    connections: Mutex<Vec<ParkedConnection>>,
+    client: AsyncSmtpClient<E>,
+    handle: OnceLock<E::Handle>,
+}
+
+struct ParkedConnection {
+    conn: AsyncSmtpConnection,
+    since: Instant,
+}
+
+pub struct PooledConnection<E: Executor> {
+    conn: Option<AsyncSmtpConnection>,
+    pool: Arc<Pool<E>>,
+}
+
+impl<E: Executor> Pool<E> {
+    pub fn new(config: PoolConfig, client: AsyncSmtpClient<E>) -> Arc<Self> {
+        let pool = Arc::new(Self {
+            config,
+            connections: Mutex::new(Vec::new()),
+            client,
+            handle: OnceLock::new(),
+        });
+
+        {
+            let pool_ = Arc::clone(&pool);
+
+            let min_idle = pool_.config.min_idle;
+            let idle_timeout = pool_.config.idle_timeout;
+            let pool = Arc::downgrade(&pool_);
+
+            let handle = E::spawn(async move {
+                loop {
+                    #[cfg(feature = "tracing")]
+                    tracing::trace!("running cleanup tasks");
+
+                    match pool.upgrade() {
+                        Some(pool) => {
+                            #[allow(clippy::needless_collect)]
+                            let (count, dropped) = {
+                                let mut connections = pool.connections.lock().await;
+
+                                let to_drop = connections
+                                    .iter()
+                                    .enumerate()
+                                    .rev()
+                                    .filter(|(_, conn)| conn.idle_duration() > idle_timeout)
+                                    .map(|(i, _)| i)
+                                    .collect::<Vec<_>>();
+                                let dropped = to_drop
+                                    .into_iter()
+                                    .map(|i| connections.remove(i))
+                                    .collect::<Vec<_>>();
+
+                                (connections.len(), dropped)
+                            };
+
+                            #[cfg(feature = "tracing")]
+                            let mut created = 0;
+                            for _ in count..=(min_idle as usize) {
+                                let conn = match pool.client.connection().await {
+                                    Ok(conn) => conn,
+                                    Err(err) => {
+                                        #[cfg(feature = "tracing")]
+                                        tracing::warn!("couldn't create idle connection {}", err);
+                                        #[cfg(not(feature = "tracing"))]
+                                        let _ = err;
+
+                                        break;
+                                    }
+                                };
+
+                                let mut connections = pool.connections.lock().await;
+                                connections.push(ParkedConnection::park(conn));
+
+                                #[cfg(feature = "tracing")]
+                                {
+                                    created += 1;
+                                }
+                            }
+
+                            #[cfg(feature = "tracing")]
+                            if created > 0 {
+                                tracing::debug!("created {} idle connections", created);
+                            }
+
+                            if !dropped.is_empty() {
+                                #[cfg(feature = "tracing")]
+                                tracing::debug!("dropped {} idle connections", dropped.len());
+
+                                abort_concurrent(dropped.into_iter().map(|conn| conn.unpark()))
+                                    .await;
+                            }
+                        }
+                        None => {
+                            #[cfg(feature = "tracing")]
+                            tracing::warn!(
+                                "breaking out of task - no more references to Pool are available"
+                            );
+                            break;
+                        }
+                    }
+
+                    E::sleep(idle_timeout).await;
+                }
+            });
+            pool_
+                .handle
+                .set(handle)
+                .expect("handle hasn't been set yet");
+        }
+
+        pool
+    }
+
+    pub async fn connection(self: &Arc<Self>) -> Result<PooledConnection<E>, Error> {
+        loop {
+            let conn = {
+                let mut connections = self.connections.lock().await;
+                connections.pop()
+            };
+
+            match conn {
+                Some(conn) => {
+                    let mut conn = conn.unpark();
+
+                    // TODO: handle the client try another connection if this one isn't good
+                    if !conn.test_connected().await {
+                        #[cfg(feature = "tracing")]
+                        tracing::debug!("dropping a broken connection");
+
+                        conn.abort().await;
+                        continue;
+                    }
+
+                    #[cfg(feature = "tracing")]
+                    tracing::debug!("reusing a pooled connection");
+
+                    return Ok(PooledConnection::wrap(conn, Arc::clone(self)));
+                }
+                None => {
+                    #[cfg(feature = "tracing")]
+                    tracing::debug!("creating a new connection");
+
+                    let conn = self.client.connection().await?;
+                    return Ok(PooledConnection::wrap(conn, Arc::clone(self)));
+                }
+            }
+        }
+    }
+
+    async fn recycle(&self, mut conn: AsyncSmtpConnection) {
+        if conn.has_broken() {
+            #[cfg(feature = "tracing")]
+            tracing::debug!("dropping a broken connection instead of recycling it");
+
+            conn.abort().await;
+            drop(conn);
+        } else {
+            #[cfg(feature = "tracing")]
+            tracing::debug!("recycling connection");
+
+            let mut connections = self.connections.lock().await;
+            if connections.len() >= self.config.max_size as usize {
+                drop(connections);
+                conn.abort().await;
+            } else {
+                let conn = ParkedConnection::park(conn);
+                connections.push(conn);
+            }
+        }
+    }
+}
+
+impl<E: Executor> Debug for Pool<E> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Pool")
+            .field("config", &self.config)
+            .field(
+                "connections",
+                &match self.connections.try_lock() {
+                    Some(connections) => format!("{} connections", connections.len()),
+
+                    None => "LOCKED".to_owned(),
+                },
+            )
+            .field("client", &self.client)
+            .field(
+                "handle",
+                &match self.handle.get() {
+                    Some(_) => "Some(JoinHandle)",
+                    None => "None",
+                },
+            )
+            .finish()
+    }
+}
+
+impl<E: Executor> Drop for Pool<E> {
+    fn drop(&mut self) {
+        #[cfg(feature = "tracing")]
+        tracing::debug!("dropping Pool");
+
+        let connections = mem::take(self.connections.get_mut());
+        let handle = self.handle.take();
+        E::spawn(async move {
+            if let Some(handle) = handle {
+                handle.shutdown().await;
+            }
+
+            abort_concurrent(connections.into_iter().map(|conn| conn.unpark())).await;
+        });
+    }
+}
+
+impl ParkedConnection {
+    fn park(conn: AsyncSmtpConnection) -> Self {
+        Self {
+            conn,
+            since: Instant::now(),
+        }
+    }
+
+    fn idle_duration(&self) -> Duration {
+        self.since.elapsed()
+    }
+
+    fn unpark(self) -> AsyncSmtpConnection {
+        self.conn
+    }
+}
+
+impl<E: Executor> PooledConnection<E> {
+    fn wrap(conn: AsyncSmtpConnection, pool: Arc<Pool<E>>) -> Self {
+        Self {
+            conn: Some(conn),
+            pool,
+        }
+    }
+}
+
+impl<E: Executor> Deref for PooledConnection<E> {
+    type Target = AsyncSmtpConnection;
+
+    fn deref(&self) -> &Self::Target {
+        self.conn.as_ref().expect("conn hasn't been dropped yet")
+    }
+}
+
+impl<E: Executor> DerefMut for PooledConnection<E> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.conn.as_mut().expect("conn hasn't been dropped yet")
+    }
+}
+
+impl<E: Executor> Drop for PooledConnection<E> {
+    fn drop(&mut self) {
+        let conn = self
+            .conn
+            .take()
+            .expect("AsyncSmtpConnection hasn't been taken yet");
+        let pool = Arc::clone(&self.pool);
+
+        E::spawn(async move {
+            pool.recycle(conn).await;
+        });
+    }
+}
+
+async fn abort_concurrent<I>(iter: I)
+where
+    I: Iterator<Item = AsyncSmtpConnection>,
+{
+    stream::iter(iter)
+        .for_each_concurrent(8, |mut conn| async move {
+            conn.abort().await;
+        })
+        .await;
+}

src/transport/smtp/pool/mod.rs

@@ -0,0 +1,66 @@
+use std::time::Duration;
+
+#[cfg(any(feature = "tokio1", feature = "async-std1"))]
+pub mod async_impl;
+pub mod sync_impl;
+
+/// Configuration for a connection pool
+#[derive(Debug, Clone)]
+#[allow(missing_copy_implementations)]
+#[cfg_attr(docsrs, doc(cfg(feature = "pool")))]
+pub struct PoolConfig {
+    min_idle: u32,
+    max_size: u32,
+    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`
+    #[doc(hidden)]
+    #[deprecated(note = "The Connection timeout is already configured on the SMTP transport")]
+    pub fn connection_timeout(self, connection_timeout: Duration) -> Self {
+        let _ = 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
+    }
+}
+
+impl Default for PoolConfig {
+    fn default() -> Self {
+        Self {
+            min_idle: 0,
+            max_size: 10,
+            idle_timeout: Duration::from_secs(60),
+        }
+    }
+}

src/transport/smtp/pool/sync_impl.rs

@@ -0,0 +1,259 @@
+use std::{
+    fmt::{self, Debug},
+    mem,
+    ops::{Deref, DerefMut},
+    sync::{Arc, Mutex, TryLockError},
+    thread,
+    time::{Duration, Instant},
+};
+
+use super::{
+    super::{client::SmtpConnection, Error},
+    PoolConfig,
+};
+use crate::transport::smtp::transport::SmtpClient;
+
+pub struct Pool {
+    config: PoolConfig,
+    connections: Mutex<Vec<ParkedConnection>>,
+    client: SmtpClient,
+}
+
+struct ParkedConnection {
+    conn: SmtpConnection,
+    since: Instant,
+}
+
+pub struct PooledConnection {
+    conn: Option<SmtpConnection>,
+    pool: Arc<Pool>,
+}
+
+impl Pool {
+    pub fn new(config: PoolConfig, client: SmtpClient) -> Arc<Self> {
+        let pool = Arc::new(Self {
+            config,
+            connections: Mutex::new(Vec::new()),
+            client,
+        });
+
+        {
+            let pool_ = Arc::clone(&pool);
+
+            let min_idle = pool_.config.min_idle;
+            let idle_timeout = pool_.config.idle_timeout;
+            let pool = Arc::downgrade(&pool_);
+
+            thread::Builder::new()
+                .name("lettre-connection-pool".into())
+                .spawn(move || {
+                    while let Some(pool) = pool.upgrade() {
+                        #[cfg(feature = "tracing")]
+                        tracing::trace!("running cleanup tasks");
+
+                        #[allow(clippy::needless_collect)]
+                        let (count, dropped) = {
+                            let mut connections = pool.connections.lock().unwrap();
+
+                            let to_drop = connections
+                                .iter()
+                                .enumerate()
+                                .rev()
+                                .filter(|(_, conn)| conn.idle_duration() > idle_timeout)
+                                .map(|(i, _)| i)
+                                .collect::<Vec<_>>();
+                            let dropped = to_drop
+                                .into_iter()
+                                .map(|i| connections.remove(i))
+                                .collect::<Vec<_>>();
+
+                            (connections.len(), dropped)
+                        };
+
+                        #[cfg(feature = "tracing")]
+                        let mut created = 0;
+                        for _ in count..=(min_idle as usize) {
+                            let conn = match pool.client.connection() {
+                                Ok(conn) => conn,
+                                Err(err) => {
+                                    #[cfg(feature = "tracing")]
+                                    tracing::warn!("couldn't create idle connection {}", err);
+                                    #[cfg(not(feature = "tracing"))]
+                                    let _ = err;
+
+                                    break;
+                                }
+                            };
+
+                            let mut connections = pool.connections.lock().unwrap();
+                            connections.push(ParkedConnection::park(conn));
+
+                            #[cfg(feature = "tracing")]
+                            {
+                                created += 1;
+                            }
+                        }
+
+                        #[cfg(feature = "tracing")]
+                        if created > 0 {
+                            tracing::debug!("created {} idle connections", created);
+                        }
+
+                        if !dropped.is_empty() {
+                            #[cfg(feature = "tracing")]
+                            tracing::debug!("dropped {} idle connections", dropped.len());
+
+                            for conn in dropped {
+                                let mut conn = conn.unpark();
+                                conn.abort();
+                            }
+                        }
+
+                        thread::sleep(idle_timeout);
+                    }
+                })
+                .expect("couldn't spawn the Pool thread");
+        }
+
+        pool
+    }
+
+    pub fn connection(self: &Arc<Self>) -> Result<PooledConnection, Error> {
+        loop {
+            let conn = {
+                let mut connections = self.connections.lock().unwrap();
+                connections.pop()
+            };
+
+            match conn {
+                Some(conn) => {
+                    let mut conn = conn.unpark();
+
+                    // TODO: handle the client try another connection if this one isn't good
+                    if !conn.test_connected() {
+                        #[cfg(feature = "tracing")]
+                        tracing::debug!("dropping a broken connection");
+
+                        conn.abort();
+                        continue;
+                    }
+
+                    #[cfg(feature = "tracing")]
+                    tracing::debug!("reusing a pooled connection");
+
+                    return Ok(PooledConnection::wrap(conn, Arc::clone(self)));
+                }
+                None => {
+                    #[cfg(feature = "tracing")]
+                    tracing::debug!("creating a new connection");
+
+                    let conn = self.client.connection()?;
+                    return Ok(PooledConnection::wrap(conn, Arc::clone(self)));
+                }
+            }
+        }
+    }
+
+    fn recycle(&self, mut conn: SmtpConnection) {
+        if conn.has_broken() {
+            #[cfg(feature = "tracing")]
+            tracing::debug!("dropping a broken connection instead of recycling it");
+
+            conn.abort();
+            drop(conn);
+        } else {
+            #[cfg(feature = "tracing")]
+            tracing::debug!("recycling connection");
+
+            let mut connections = self.connections.lock().unwrap();
+            if connections.len() >= self.config.max_size as usize {
+                drop(connections);
+                conn.abort();
+            } else {
+                let conn = ParkedConnection::park(conn);
+                connections.push(conn);
+            }
+        }
+    }
+}
+
+impl Debug for Pool {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Pool")
+            .field("config", &self.config)
+            .field(
+                "connections",
+                &match self.connections.try_lock() {
+                    Ok(connections) => format!("{} connections", connections.len()),
+
+                    Err(TryLockError::WouldBlock) => "LOCKED".to_owned(),
+                    Err(TryLockError::Poisoned(_)) => "POISONED".to_owned(),
+                },
+            )
+            .field("client", &self.client)
+            .finish()
+    }
+}
+
+impl Drop for Pool {
+    fn drop(&mut self) {
+        #[cfg(feature = "tracing")]
+        tracing::debug!("dropping Pool");
+
+        let connections = mem::take(&mut *self.connections.get_mut().unwrap());
+        for conn in connections {
+            let mut conn = conn.unpark();
+            conn.abort();
+        }
+    }
+}
+
+impl ParkedConnection {
+    fn park(conn: SmtpConnection) -> Self {
+        Self {
+            conn,
+            since: Instant::now(),
+        }
+    }
+
+    fn idle_duration(&self) -> Duration {
+        self.since.elapsed()
+    }
+
+    fn unpark(self) -> SmtpConnection {
+        self.conn
+    }
+}
+
+impl PooledConnection {
+    fn wrap(conn: SmtpConnection, pool: Arc<Pool>) -> Self {
+        Self {
+            conn: Some(conn),
+            pool,
+        }
+    }
+}
+
+impl Deref for PooledConnection {
+    type Target = SmtpConnection;
+
+    fn deref(&self) -> &Self::Target {
+        self.conn.as_ref().expect("conn hasn't been dropped yet")
+    }
+}
+
+impl DerefMut for PooledConnection {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.conn.as_mut().expect("conn hasn't been dropped yet")
+    }
+}
+
+impl Drop for PooledConnection {
+    fn drop(&mut self) {
+        let conn = self
+            .conn
+            .take()
+            .expect("SmtpConnection hasn't been taken yet");
+        self.pool.recycle(conn);
+    }
+}

src/transport/smtp/response.rs

@@ -1,7 +1,12 @@
 //! SMTP response, containing a mandatory return code and an optional text
 //! message
 
-use crate::transport::smtp::{error, Error};
+use std::{
+    fmt::{Display, Formatter, Result},
+    result,
+    str::FromStr,
+};
+
 use nom::{
     branch::alt,
     bytes::streaming::{tag, take_until},
@@ -10,14 +15,10 @@ use nom::{
     sequence::{preceded, tuple},
     IResult,
 };
-use std::{
-    fmt::{Display, Formatter, Result},
-    result,
-    str::FromStr,
-    string::ToString,
-};
 
-/// First digit indicates severity
+use crate::transport::smtp::{error, Error};
+
+/// The first digit indicates severity
 #[derive(PartialEq, Eq, Copy, Clone, Debug)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum Severity {
@@ -130,6 +131,12 @@ impl Code {
     }
 }
 
+impl From<Code> for u16 {
+    fn from(code: Code) -> Self {
+        code.detail as u16 + 10 * code.category as u16 + 100 * code.severity as u16
+    }
+}
+
 /// Contains an SMTP reply, with separated code and message
 ///
 /// The text message is optional, only the code is mandatory
@@ -137,10 +144,10 @@ impl Code {
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Response {
     /// Response code
-    pub code: Code,
+    code: Code,
     /// Server response string (optional)
     /// Handle multiline responses
-    pub message: Vec<String>,
+    message: Vec<String>,
 }
 
 impl FromStr for Response {
@@ -149,7 +156,7 @@ impl FromStr for Response {
     fn from_str(s: &str) -> result::Result<Response, Error> {
         parse_response(s)
             .map(|(_, r)| r)
-            .map_err(|e| error::response(e.to_string()))
+            .map_err(|e| error::response(e.to_owned()))
     }
 }
 
@@ -180,6 +187,16 @@ impl Response {
     pub fn first_line(&self) -> Option<&str> {
         self.message.first().map(String::as_str)
     }
+
+    /// Response code
+    pub fn code(&self) -> Code {
+        self.code
+    }
+
+    /// Server response string (array of lines)
+    pub fn message(&self) -> impl Iterator<Item = &str> {
+        self.message.iter().map(String::as_str)
+    }
 }
 
 // Parsers (originally from tokio-smtp)
@@ -305,6 +322,17 @@ mod test {
         assert_eq!(code.to_string(), "421");
     }
 
+    #[test]
+    fn test_code_to_u16() {
+        let code = Code {
+            severity: Severity::TransientNegativeCompletion,
+            category: Category::Connections,
+            detail: Detail::One,
+        };
+        let c: u16 = code.into();
+        assert_eq!(c, 421);
+    }
+
     #[test]
     fn test_response_from_str() {
         let raw_response = "250-me\r\n250-8BITMIME\r\n250-SIZE 42\r\n250 AUTH PLAIN CRAM-MD5\r\n";
@@ -317,10 +345,10 @@ mod test {
                     detail: Detail::Zero,
                 },
                 message: vec![
-                    "me".to_string(),
-                    "8BITMIME".to_string(),
-                    "SIZE 42".to_string(),
-                    "AUTH PLAIN CRAM-MD5".to_string(),
+                    "me".to_owned(),
+                    "8BITMIME".to_owned(),
+                    "SIZE 42".to_owned(),
+                    "AUTH PLAIN CRAM-MD5".to_owned(),
                 ],
             }
         );
@@ -340,11 +368,7 @@ mod test {
                 category: Category::MailSystem,
                 detail: Detail::Zero,
             },
-            vec![
-                "me".to_string(),
-                "8BITMIME".to_string(),
-                "SIZE 42".to_string(),
-            ],
+            vec!["me".to_owned(), "8BITMIME".to_owned(), "SIZE 42".to_owned(),],
         )
         .is_positive());
         assert!(!Response::new(
@@ -353,11 +377,7 @@ mod test {
                 category: Category::MailSystem,
                 detail: Detail::Zero,
             },
-            vec![
-                "me".to_string(),
-                "8BITMIME".to_string(),
-                "SIZE 42".to_string(),
-            ],
+            vec!["me".to_owned(), "8BITMIME".to_owned(), "SIZE 42".to_owned(),],
         )
         .is_positive());
     }
@@ -370,11 +390,7 @@ mod test {
                 category: Category::MailSystem,
                 detail: Detail::One,
             },
-            vec![
-                "me".to_string(),
-                "8BITMIME".to_string(),
-                "SIZE 42".to_string(),
-            ],
+            vec!["me".to_owned(), "8BITMIME".to_owned(), "SIZE 42".to_owned(),],
         )
         .has_code(451));
         assert!(!Response::new(
@@ -383,11 +399,7 @@ mod test {
                 category: Category::MailSystem,
                 detail: Detail::One,
             },
-            vec![
-                "me".to_string(),
-                "8BITMIME".to_string(),
-                "SIZE 42".to_string(),
-            ],
+            vec!["me".to_owned(), "8BITMIME".to_owned(), "SIZE 42".to_owned(),],
         )
         .has_code(251));
     }
@@ -401,11 +413,7 @@ mod test {
                     category: Category::MailSystem,
                     detail: Detail::One,
                 },
-                vec![
-                    "me".to_string(),
-                    "8BITMIME".to_string(),
-                    "SIZE 42".to_string(),
-                ],
+                vec!["me".to_owned(), "8BITMIME".to_owned(), "SIZE 42".to_owned(),],
             )
             .first_word(),
             Some("me")
@@ -418,9 +426,9 @@ mod test {
                     detail: Detail::One,
                 },
                 vec![
-                    "me mo".to_string(),
-                    "8BITMIME".to_string(),
-                    "SIZE 42".to_string(),
+                    "me mo".to_owned(),
+                    "8BITMIME".to_owned(),
+                    "SIZE 42".to_owned(),
                 ],
             )
             .first_word(),
@@ -445,7 +453,7 @@ mod test {
                     category: Category::MailSystem,
                     detail: Detail::One,
                 },
-                vec![" ".to_string()],
+                vec![" ".to_owned()],
             )
             .first_word(),
             None
@@ -457,7 +465,7 @@ mod test {
                     category: Category::MailSystem,
                     detail: Detail::One,
                 },
-                vec!["  ".to_string()],
+                vec!["  ".to_owned()],
             )
             .first_word(),
             None
@@ -469,7 +477,7 @@ mod test {
                     category: Category::MailSystem,
                     detail: Detail::One,
                 },
-                vec!["".to_string()],
+                vec!["".to_owned()],
             )
             .first_word(),
             None
@@ -482,7 +490,7 @@ mod test {
         let res = parse_response(raw_response);
         match res {
             Err(nom::Err::Incomplete(_)) => {}
-            _ => panic!("Expected incomplete response, got {:?}", res),
+            _ => panic!("Expected incomplete response, got {res:?}"),
         }
     }
 
@@ -495,11 +503,7 @@ mod test {
                     category: Category::MailSystem,
                     detail: Detail::One,
                 },
-                vec![
-                    "me".to_string(),
-                    "8BITMIME".to_string(),
-                    "SIZE 42".to_string(),
-                ],
+                vec!["me".to_owned(), "8BITMIME".to_owned(), "SIZE 42".to_owned(),],
             )
             .first_line(),
             Some("me")
@@ -512,9 +516,9 @@ mod test {
                     detail: Detail::One,
                 },
                 vec![
-                    "me mo".to_string(),
-                    "8BITMIME".to_string(),
-                    "SIZE 42".to_string(),
+                    "me mo".to_owned(),
+                    "8BITMIME".to_owned(),
+                    "SIZE 42".to_owned(),
                 ],
             )
             .first_line(),
@@ -539,7 +543,7 @@ mod test {
                     category: Category::MailSystem,
                     detail: Detail::One,
                 },
-                vec![" ".to_string()],
+                vec![" ".to_owned()],
             )
             .first_line(),
             Some(" ")
@@ -551,7 +555,7 @@ mod test {
                     category: Category::MailSystem,
                     detail: Detail::One,
                 },
-                vec!["  ".to_string()],
+                vec!["  ".to_owned()],
             )
             .first_line(),
             Some("  ")
@@ -563,7 +567,7 @@ mod test {
                     category: Category::MailSystem,
                     detail: Detail::One,
                 },
-                vec!["".to_string()],
+                vec!["".to_owned()],
             )
             .first_line(),
             Some("")

src/transport/smtp/transport.rs

@@ -1,22 +1,23 @@
-use std::time::Duration;
+#[cfg(feature = "pool")]
+use std::sync::Arc;
+use std::{fmt::Debug, time::Duration};
 
-#[cfg(feature = "r2d2")]
-use r2d2::Pool;
-
-#[cfg(feature = "r2d2")]
+#[cfg(feature = "pool")]
+use super::pool::sync_impl::Pool;
+#[cfg(feature = "pool")]
 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};
+#[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+use super::{Tls, TlsParameters, SUBMISSIONS_PORT, SUBMISSION_PORT};
 use crate::{address::Envelope, Transport};
 
 /// Sends emails using the SMTP protocol
 #[cfg_attr(docsrs, doc(cfg(feature = "smtp-transport")))]
 #[derive(Clone)]
 pub struct SmtpTransport {
-    #[cfg(feature = "r2d2")]
-    inner: Pool<SmtpClient>,
-    #[cfg(not(feature = "r2d2"))]
+    #[cfg(feature = "pool")]
+    inner: Arc<Pool>,
+    #[cfg(not(feature = "pool"))]
     inner: SmtpClient,
 }
 
@@ -26,20 +27,25 @@ 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)?;
-        #[cfg(not(feature = "r2d2"))]
         let mut conn = self.inner.connection()?;
 
         let result = conn.send(envelope, email)?;
 
-        #[cfg(not(feature = "r2d2"))]
+        #[cfg(not(feature = "pool"))]
         conn.quit()?;
 
         Ok(result)
     }
 }
 
+impl Debug for SmtpTransport {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut builder = f.debug_struct("SmtpTransport");
+        builder.field("inner", &self.inner);
+        builder.finish()
+    }
+}
+
 impl SmtpTransport {
     /// Simple and secure transport, using TLS connections to communicate with the SMTP server
     ///
@@ -47,8 +53,11 @@ impl SmtpTransport {
     ///
     /// Creates an encrypted transport over submissions port, using the provided domain
     /// to validate TLS certificates.
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
     pub fn relay(relay: &str) -> Result<SmtpTransportBuilder, Error> {
         let tls_parameters = TlsParameters::new(relay.into())?;
 
@@ -57,7 +66,7 @@ impl SmtpTransport {
             .tls(Tls::Wrapper(tls_parameters)))
     }
 
-    /// Simple an secure transport, using STARTTLS to obtain encrypted connections
+    /// Simple and secure transport, using STARTTLS to obtain encrypted connections
     ///
     /// Alternative to [`SmtpTransport::relay`](#method.relay), for SMTP servers
     /// that don't take SMTPS connections.
@@ -68,8 +77,11 @@ impl SmtpTransport {
     ///
     /// An error is returned if the connection can't be upgraded. No credentials
     /// or emails will be sent to the server, protecting from downgrade attacks.
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
     pub fn starttls_relay(relay: &str) -> Result<SmtpTransportBuilder, Error> {
         let tls_parameters = TlsParameters::new(relay.into())?;
 
@@ -91,23 +103,115 @@ impl SmtpTransport {
     ///
     /// * No authentication
     /// * No TLS
-    /// * A 60 seconds timeout for smtp commands
+    /// * A 60-seconds timeout for smtp commands
     /// * Port 25
     ///
     /// Consider using [`SmtpTransport::relay`](#method.relay) or
     /// [`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::new(server)
+    }
 
-        SmtpTransportBuilder {
-            info: new,
-            #[cfg(feature = "r2d2")]
-            pool_config: PoolConfig::default(),
-        }
+    /// Creates a `SmtpTransportBuilder` from a connection URL
+    ///
+    /// The protocol, credentials, host and port can be provided in a single URL.
+    /// Use the scheme `smtp` for an unencrypted relay (optionally in combination with the
+    /// `tls` parameter to allow/require STARTTLS) or `smtps` for SMTP over TLS.
+    /// The path section of the url can be used to set an alternative name for
+    /// the HELO / EHLO command.
+    /// For example `smtps://username:password@smtp.example.com/client.example.com:465`
+    /// will set the HELO / EHLO name `client.example.com`.
+    ///
+    /// <table>
+    ///   <thead>
+    ///     <tr>
+    ///       <th>scheme</th>
+    ///       <th>tls parameter</th>
+    ///       <th>example</th>
+    ///       <th>remarks</th>
+    ///     </tr>
+    ///   </thead>
+    ///   <tbody>
+    ///     <tr>
+    ///      <td>smtps</td>
+    ///      <td>-</td>
+    ///      <td>smtps://smtp.example.com</td>
+    ///      <td>SMTP over TLS, recommended method</td>
+    ///     </tr>
+    ///     <tr>
+    ///      <td>smtp</td>
+    ///      <td>required</td>
+    ///      <td>smtp://smtp.example.com?tls=required</td>
+    ///      <td>SMTP with STARTTLS required, when SMTP over TLS is not available</td>
+    ///     </tr>
+    ///     <tr>
+    ///      <td>smtp</td>
+    ///      <td>opportunistic</td>
+    ///      <td>smtp://smtp.example.com?tls=opportunistic</td>
+    ///      <td>
+    ///         SMTP with optionally STARTTLS when supported by the server.
+    ///         Caution: this method is vulnerable to a man-in-the-middle attack.
+    ///         Not recommended for production use.
+    ///       </td>
+    ///     </tr>
+    ///     <tr>
+    ///      <td>smtp</td>
+    ///      <td>-</td>
+    ///      <td>smtp://smtp.example.com</td>
+    ///      <td>Unencrypted SMTP, not recommended for production use.</td>
+    ///     </tr>
+    ///   </tbody>
+    /// </table>
+    ///
+    /// ```rust,no_run
+    /// use lettre::{
+    ///     message::header::ContentType, transport::smtp::authentication::Credentials, Message,
+    ///     SmtpTransport, Transport,
+    /// };
+    ///
+    /// 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")
+    ///     .header(ContentType::TEXT_PLAIN)
+    ///     .body(String::from("Be happy!"))
+    ///     .unwrap();
+    ///
+    /// // Open a remote connection to example
+    /// let mailer = SmtpTransport::from_url("smtps://username:password@smtp.example.com:465")
+    ///     .unwrap()
+    ///     .build();
+    ///
+    /// // Send the email
+    /// match mailer.send(&email) {
+    ///     Ok(_) => println!("Email sent successfully!"),
+    ///     Err(e) => panic!("Could not send email: {e:?}"),
+    /// }
+    /// ```
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
+    pub fn from_url(connection_url: &str) -> Result<SmtpTransportBuilder, Error> {
+        super::connection_url::from_connection_url(connection_url)
+    }
+
+    /// Tests the SMTP connection
+    ///
+    /// `test_connection()` tests the connection by using the SMTP NOOP command.
+    /// The connection is closed afterward if a connection pool is not used.
+    pub fn test_connection(&self) -> Result<bool, Error> {
+        let mut conn = self.inner.connection()?;
+
+        let is_connected = conn.test_connected();
+
+        #[cfg(not(feature = "pool"))]
+        conn.quit()?;
+
+        Ok(is_connected)
     }
 }
 
@@ -116,12 +220,26 @@ impl SmtpTransport {
 #[derive(Debug, Clone)]
 pub struct SmtpTransportBuilder {
     info: SmtpInfo,
-    #[cfg(feature = "r2d2")]
+    #[cfg(feature = "pool")]
     pool_config: PoolConfig,
 }
 
 /// Builder for the SMTP `SmtpTransport`
 impl SmtpTransportBuilder {
+    // Create new builder with default parameters
+    pub(crate) fn new<T: Into<String>>(server: T) -> Self {
+        let new = SmtpInfo {
+            server: server.into(),
+            ..Default::default()
+        };
+
+        Self {
+            info: new,
+            #[cfg(feature = "pool")]
+            pool_config: PoolConfig::default(),
+        }
+    }
+
     /// Set the name used during EHLO
     pub fn hello_name(mut self, name: ClientId) -> Self {
         self.info.hello_name = name;
@@ -153,8 +271,11 @@ impl SmtpTransportBuilder {
     }
 
     /// Set the TLS settings to use
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
     pub fn tls(mut self, tls: Tls) -> Self {
         self.info.tls = tls;
         self
@@ -163,8 +284,8 @@ impl SmtpTransportBuilder {
     /// Use a custom configuration for the connection pool
     ///
     /// Defaults can be found at [`PoolConfig`]
-    #[cfg(feature = "r2d2")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "r2d2")))]
+    #[cfg(feature = "pool")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "pool")))]
     pub fn pool_config(mut self, pool_config: PoolConfig) -> Self {
         self.pool_config = pool_config;
         self
@@ -172,16 +293,15 @@ impl SmtpTransportBuilder {
 
     /// Build the transport
     ///
-    /// If the `r2d2` feature is enabled an `Arc` wrapped pool is be created.
+    /// If the `pool` feature is enabled, an `Arc` wrapped pool is created.
     /// Defaults can be found at [`PoolConfig`]
     pub fn build(self) -> SmtpTransport {
         let client = SmtpClient { info: self.info };
-        SmtpTransport {
-            #[cfg(feature = "r2d2")]
-            inner: self.pool_config.build(client),
-            #[cfg(not(feature = "r2d2"))]
-            inner: client,
-        }
+
+        #[cfg(feature = "pool")]
+        let client = Pool::new(self.pool_config, client);
+
+        SmtpTransport { inner: client }
     }
 }
 
@@ -197,9 +317,9 @@ impl SmtpClient {
     /// Handles encryption and authentication
     pub fn connection(&self) -> Result<SmtpConnection, Error> {
         #[allow(clippy::match_single_binding)]
-        let tls_parameters = match self.info.tls {
-            #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-            Tls::Wrapper(ref tls_parameters) => Some(tls_parameters),
+        let tls_parameters = match &self.info.tls {
+            #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+            Tls::Wrapper(tls_parameters) => Some(tls_parameters),
             _ => None,
         };
 
@@ -209,24 +329,100 @@ impl SmtpClient {
             self.info.timeout,
             &self.info.hello_name,
             tls_parameters,
+            None,
         )?;
 
-        #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-        match self.info.tls {
-            Tls::Opportunistic(ref tls_parameters) => {
+        #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+        match &self.info.tls {
+            Tls::Opportunistic(tls_parameters) => {
                 if conn.can_starttls() {
                     conn.starttls(tls_parameters, &self.info.hello_name)?;
                 }
             }
-            Tls::Required(ref tls_parameters) => {
+            Tls::Required(tls_parameters) => {
                 conn.starttls(tls_parameters, &self.info.hello_name)?;
             }
             _ => (),
         }
 
         if let Some(credentials) = &self.info.credentials {
-            conn.auth(&self.info.authentication, &credentials)?;
+            conn.auth(&self.info.authentication, credentials)?;
         }
         Ok(conn)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        transport::smtp::{authentication::Credentials, client::Tls},
+        SmtpTransport,
+    };
+
+    #[test]
+    fn transport_from_url() {
+        let builder = SmtpTransport::from_url("smtp://127.0.0.1:2525").unwrap();
+
+        assert_eq!(builder.info.port, 2525);
+        assert!(matches!(builder.info.tls, Tls::None));
+        assert_eq!(builder.info.server, "127.0.0.1");
+
+        let builder =
+            SmtpTransport::from_url("smtps://username:password@smtp.example.com:465").unwrap();
+
+        assert_eq!(builder.info.port, 465);
+        assert_eq!(
+            builder.info.credentials,
+            Some(Credentials::new(
+                "username".to_owned(),
+                "password".to_owned()
+            ))
+        );
+        assert!(matches!(builder.info.tls, Tls::Wrapper(_)));
+        assert_eq!(builder.info.server, "smtp.example.com");
+
+        let builder = SmtpTransport::from_url(
+            "smtps://user%40example.com:pa$$word%3F%22!@smtp.example.com:465",
+        )
+        .unwrap();
+
+        assert_eq!(builder.info.port, 465);
+        assert_eq!(
+            builder.info.credentials,
+            Some(Credentials::new(
+                "user@example.com".to_owned(),
+                "pa$$word?\"!".to_owned()
+            ))
+        );
+        assert!(matches!(builder.info.tls, Tls::Wrapper(_)));
+        assert_eq!(builder.info.server, "smtp.example.com");
+
+        let builder =
+            SmtpTransport::from_url("smtp://username:password@smtp.example.com:587?tls=required")
+                .unwrap();
+
+        assert_eq!(builder.info.port, 587);
+        assert_eq!(
+            builder.info.credentials,
+            Some(Credentials::new(
+                "username".to_owned(),
+                "password".to_owned()
+            ))
+        );
+        assert!(matches!(builder.info.tls, Tls::Required(_)));
+
+        let builder = SmtpTransport::from_url(
+            "smtp://username:password@smtp.example.com:587?tls=opportunistic",
+        )
+        .unwrap();
+
+        assert_eq!(builder.info.port, 587);
+        assert!(matches!(builder.info.tls, Tls::Opportunistic(_)));
+
+        let builder = SmtpTransport::from_url("smtps://smtp.example.com").unwrap();
+
+        assert_eq!(builder.info.port, 465);
+        assert_eq!(builder.info.credentials, None);
+        assert!(matches!(builder.info.tls, Tls::Wrapper(_)));
+    }
+}

src/transport/smtp/util.rs

@@ -4,7 +4,6 @@ use std::fmt::{Display, Formatter, Result as FmtResult};
 
 /// Encode a string as xtext
 #[derive(Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct XText<'a>(pub &'a str);
 
 impl<'a> Display for XText<'a> {
@@ -42,7 +41,7 @@ mod tests {
         ]
         .iter()
         {
-            assert_eq!(format!("{}", XText(input)), expect.to_string());
+            assert_eq!(format!("{}", XText(input)), (*expect).to_owned());
         }
     }
 }

src/transport/stub/mod.rs

@@ -1,10 +1,12 @@
-//! The stub transport only logs message envelope and drops the content. It can be useful for
-//! testing purposes.
+//! The stub transport logs message envelopes as well as contents. It can be useful for testing
+//! purposes.
 //!
-//! #### Stub Transport
+//! # Stub Transport
 //!
-//! The stub transport returns provided result and drops the content. It can be useful for
-//! testing purposes.
+//! The stub transport logs message envelopes as well as contents. It can be useful for testing
+//! purposes.
+//!
+//! # Examples
 //!
 //! ```rust
 //! # #[cfg(feature = "builder")]
@@ -12,7 +14,7 @@
 //! use lettre::{transport::stub::StubTransport, Message, Transport};
 //!
 //! # use std::error::Error;
-//! # fn main() -> Result<(), Box<dyn Error>> {
+//! # fn try_main() -> Result<(), Box<dyn Error>> {
 //! let email = Message::builder()
 //!     .from("NoBody <nobody@domain.tld>".parse()?)
 //!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
@@ -23,18 +25,36 @@
 //! let mut sender = StubTransport::new_ok();
 //! let result = sender.send(&email);
 //! assert!(result.is_ok());
+//! assert_eq!(
+//!     sender.messages(),
+//!     vec![(
+//!         email.envelope().clone(),
+//!         String::from_utf8(email.formatted()).unwrap()
+//!     )],
+//! );
 //! # Ok(())
 //! # }
+//! # try_main().unwrap();
 //! # }
 //! ```
 
+use std::{
+    error::Error as StdError,
+    fmt,
+    sync::{Arc, Mutex as StdMutex},
+};
+
+#[cfg(any(feature = "tokio1", feature = "async-std1"))]
+use async_trait::async_trait;
+#[cfg(any(feature = "tokio1", feature = "async-std1"))]
+use futures_util::lock::Mutex as FuturesMutex;
+
 #[cfg(any(feature = "tokio1", feature = "async-std1"))]
 use crate::AsyncTransport;
 use crate::{address::Envelope, Transport};
-#[cfg(any(feature = "tokio1", feature = "async-std1"))]
-use async_trait::async_trait;
-use std::{error::Error as StdError, fmt};
 
+/// An error returned by the stub transport
+#[non_exhaustive]
 #[derive(Debug, Copy, Clone)]
 pub struct Error;
 
@@ -46,47 +66,113 @@ impl fmt::Display for Error {
 
 impl StdError for Error {}
 
-/// This transport logs the message envelope and returns the given response
-#[derive(Debug, Clone, Copy)]
+/// This transport logs messages and always returns the given response
+#[derive(Debug, Clone)]
 pub struct StubTransport {
     response: Result<(), Error>,
+    message_log: Arc<StdMutex<Vec<(Envelope, String)>>>,
+}
+
+/// This transport logs messages and always returns the given response
+#[derive(Debug, Clone)]
+#[cfg(any(feature = "tokio1", feature = "async-std1"))]
+#[cfg_attr(docsrs, doc(cfg(any(feature = "tokio1", feature = "async-std1"))))]
+pub struct AsyncStubTransport {
+    response: Result<(), Error>,
+    message_log: Arc<FuturesMutex<Vec<(Envelope, String)>>>,
 }
 
 impl StubTransport {
     /// Creates a new transport that always returns the given Result
-    pub fn new(response: Result<(), Error>) -> StubTransport {
-        StubTransport { response }
+    pub fn new(response: Result<(), Error>) -> Self {
+        Self {
+            response,
+            message_log: Arc::new(StdMutex::new(vec![])),
+        }
     }
 
     /// Creates a new transport that always returns a success response
-    pub fn new_ok() -> StubTransport {
-        StubTransport { response: Ok(()) }
+    pub fn new_ok() -> Self {
+        Self {
+            response: Ok(()),
+            message_log: Arc::new(StdMutex::new(vec![])),
+        }
     }
 
     /// Creates a new transport that always returns an error
-    pub fn new_error() -> StubTransport {
-        StubTransport {
+    pub fn new_error() -> Self {
+        Self {
             response: Err(Error),
+            message_log: Arc::new(StdMutex::new(vec![])),
         }
     }
+
+    /// Return all logged messages sent using [`Transport::send_raw`]
+    pub fn messages(&self) -> Vec<(Envelope, String)> {
+        self.message_log
+            .lock()
+            .expect("Couldn't acquire lock to write message log")
+            .clone()
+    }
+}
+
+#[cfg(any(feature = "async-std1", feature = "tokio1"))]
+impl AsyncStubTransport {
+    /// Creates a new transport that always returns the given Result
+    pub fn new(response: Result<(), Error>) -> Self {
+        Self {
+            response,
+            message_log: Arc::new(FuturesMutex::new(vec![])),
+        }
+    }
+
+    /// Creates a new transport that always returns a success response
+    pub fn new_ok() -> Self {
+        Self {
+            response: Ok(()),
+            message_log: Arc::new(FuturesMutex::new(vec![])),
+        }
+    }
+
+    /// Creates a new transport that always returns an error
+    pub fn new_error() -> Self {
+        Self {
+            response: Err(Error),
+            message_log: Arc::new(FuturesMutex::new(vec![])),
+        }
+    }
+
+    /// Return all logged messages sent using [`AsyncTransport::send_raw`]
+    #[cfg(any(feature = "tokio1", feature = "async-std1"))]
+    pub async fn messages(&self) -> Vec<(Envelope, String)> {
+        self.message_log.lock().await.clone()
+    }
 }
 
 impl Transport for StubTransport {
     type Ok = ();
     type Error = Error;
 
-    fn send_raw(&self, _envelope: &Envelope, _email: &[u8]) -> Result<Self::Ok, Self::Error> {
+    fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
+        self.message_log
+            .lock()
+            .expect("Couldn't acquire lock to write message log")
+            .push((envelope.clone(), String::from_utf8_lossy(email).into()));
         self.response
     }
 }
 
 #[cfg(any(feature = "tokio1", feature = "async-std1"))]
 #[async_trait]
-impl AsyncTransport for StubTransport {
+impl AsyncTransport for AsyncStubTransport {
     type Ok = ();
     type Error = Error;
 
-    async fn send_raw(&self, _envelope: &Envelope, _email: &[u8]) -> Result<Self::Ok, Self::Error> {
+    async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
+        self.message_log
+            .lock()
+            .await
+            .push((envelope.clone(), String::from_utf8_lossy(email).into()));
         self.response
     }
 }

testdata/coredns.conf

@@ -0,0 +1,7 @@
+. {
+  bind 127.0.0.54
+  forward . 9.9.9.9 8.8.8.8 1.1.1.1 {
+    except example.org
+  }
+  file testdata/db.example.org example.org
+}

testdata/db.example.org

@@ -0,0 +1,2 @@
+@       600     IN      SOA     ns.example.org hostmaster.example.org 1 10800 3600 604800 3600
+dkimtest._domainkey 600 IN TXT  "v=DKIM1; k=rsa; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAz+FHbM8BwkBBz/Ux5OYLQ5Bp1HVuCHTP6Rr3HXTnome/2cGl/ze0tsmmFbCjjsS89MXbMGs9xJhjv18LmL1N0UTllblOizzVjorQyN4RwBOfG34j7SS56pwzrA738Ry8FAbL5InPWEgVzbOhXuTCs8yuzcqTnm4sH/csnIl7cMWeQkVn1FR9LKMtUG0fjhDPkdX0jx3qTX1L3Z7a7gX6geY191yNd9i9DvE2/+wMigMYz1LAts4alk2g86MQhtbjc8AOR7EC15hSw37/lmamlunYLa3wC+PzHNMA8sAfnmkgNvipssjh8LnelD9qn+VtsjQB5ppkeQx3TcUPvz5z+QIDAQAB"

testdata/email_with_png.eml

@@ -1,4 +1,4 @@
-Date: Tue, 15 Nov 1994 08:12:31 -0000
+Date: Tue, 15 Nov 1994 08:12:31 +0000
 From: NoBody <nobody@domain.tld>
 Reply-To: Yuin <yuin@domain.tld>
 To: Hei <hei@domain.tld>

tests/transport_file.rs

@@ -9,13 +9,15 @@ fn default_date() -> std::time::SystemTime {
 #[cfg(test)]
 #[cfg(all(feature = "file-transport", feature = "builder"))]
 mod sync {
-    use crate::default_date;
-    use lettre::{FileTransport, Message, Transport};
     use std::{
         env::temp_dir,
         fs::{read_to_string, remove_file},
     };
 
+    use lettre::{FileTransport, Message, Transport};
+
+    use crate::default_date;
+
     #[test]
     fn file_transport() {
         let sender = FileTransport::new(temp_dir());
@@ -31,7 +33,7 @@ mod sync {
         let result = sender.send(&email);
         let id = result.unwrap();
 
-        let eml_file = temp_dir().join(format!("{}.eml", id));
+        let eml_file = temp_dir().join(format!("{id}.eml"));
         let eml = read_to_string(&eml_file).unwrap();
 
         assert_eq!(
@@ -41,7 +43,7 @@ mod sync {
                 "Reply-To: Yuin <yuin@domain.tld>\r\n",
                 "To: Hei <hei@domain.tld>\r\n",
                 "Subject: Happy new year\r\n",
-                "Date: Tue, 15 Nov 1994 08:12:31 -0000\r\n",
+                "Date: Tue, 15 Nov 1994 08:12:31 +0000\r\n",
                 "Content-Transfer-Encoding: 7bit\r\n",
                 "\r\n",
                 "Be happy!"
@@ -66,10 +68,10 @@ mod sync {
         let result = sender.send(&email);
         let id = result.unwrap();
 
-        let eml_file = temp_dir().join(format!("{}.eml", id));
+        let eml_file = temp_dir().join(format!("{id}.eml"));
         let eml = read_to_string(&eml_file).unwrap();
 
-        let json_file = temp_dir().join(format!("{}.json", id));
+        let json_file = temp_dir().join(format!("{id}.json"));
         let json = read_to_string(&json_file).unwrap();
 
         assert_eq!(
@@ -79,7 +81,7 @@ mod sync {
                 "Reply-To: Yuin <yuin@domain.tld>\r\n",
                 "To: Hei <hei@domain.tld>\r\n",
                 "Subject: Happy new year\r\n",
-                "Date: Tue, 15 Nov 1994 08:12:31 -0000\r\n",
+                "Date: Tue, 15 Nov 1994 08:12:31 +0000\r\n",
                 "Content-Transfer-Encoding: 7bit\r\n",
                 "\r\n",
                 "Be happy!"
@@ -104,15 +106,16 @@ mod sync {
 #[cfg(test)]
 #[cfg(all(feature = "file-transport", feature = "builder", feature = "tokio1"))]
 mod tokio_1 {
-    use crate::default_date;
-    use lettre::{AsyncFileTransport, AsyncTransport, Message, Tokio1Executor};
     use std::{
         env::temp_dir,
         fs::{read_to_string, remove_file},
     };
 
+    use lettre::{AsyncFileTransport, AsyncTransport, Message, Tokio1Executor};
     use tokio1_crate as tokio;
 
+    use crate::default_date;
+
     #[tokio::test]
     async fn file_transport_tokio1() {
         let sender = AsyncFileTransport::<Tokio1Executor>::new(temp_dir());
@@ -128,7 +131,7 @@ mod tokio_1 {
         let result = sender.send(email).await;
         let id = result.unwrap();
 
-        let eml_file = temp_dir().join(format!("{}.eml", id));
+        let eml_file = temp_dir().join(format!("{id}.eml"));
         let eml = read_to_string(&eml_file).unwrap();
 
         assert_eq!(
@@ -138,7 +141,7 @@ mod tokio_1 {
                 "Reply-To: Yuin <yuin@domain.tld>\r\n",
                 "To: Hei <hei@domain.tld>\r\n",
                 "Subject: Happy new year\r\n",
-                "Date: Tue, 15 Nov 1994 08:12:31 -0000\r\n",
+                "Date: Tue, 15 Nov 1994 08:12:31 +0000\r\n",
                 "Content-Transfer-Encoding: 7bit\r\n",
                 "\r\n",
                 "Be happy!"
@@ -155,13 +158,15 @@ mod tokio_1 {
     feature = "async-std1"
 ))]
 mod asyncstd_1 {
-    use crate::default_date;
-    use lettre::{AsyncFileTransport, AsyncStd1Executor, AsyncTransport, Message};
     use std::{
         env::temp_dir,
         fs::{read_to_string, remove_file},
     };
 
+    use lettre::{AsyncFileTransport, AsyncStd1Executor, AsyncTransport, Message};
+
+    use crate::default_date;
+
     #[async_std::test]
     async fn file_transport_asyncstd1() {
         let sender = AsyncFileTransport::<AsyncStd1Executor>::new(temp_dir());
@@ -177,7 +182,7 @@ mod asyncstd_1 {
         let result = sender.send(email).await;
         let id = result.unwrap();
 
-        let eml_file = temp_dir().join(format!("{}.eml", id));
+        let eml_file = temp_dir().join(format!("{id}.eml"));
         let eml = read_to_string(&eml_file).unwrap();
 
         assert_eq!(
@@ -187,7 +192,7 @@ mod asyncstd_1 {
                 "Reply-To: Yuin <yuin@domain.tld>\r\n",
                 "To: Hei <hei@domain.tld>\r\n",
                 "Subject: Happy new year\r\n",
-                "Date: Tue, 15 Nov 1994 08:12:31 -0000\r\n",
+                "Date: Tue, 15 Nov 1994 08:12:31 +0000\r\n",
                 "Content-Transfer-Encoding: 7bit\r\n",
                 "\r\n",
                 "Be happy!"

tests/transport_sendmail.rs

@@ -15,7 +15,7 @@ mod sync {
             .unwrap();
 
         let result = sender.send(&email);
-        println!("{:?}", result);
+        println!("{result:?}");
         assert!(result.is_ok());
     }
 }
@@ -42,7 +42,7 @@ mod tokio_1 {
             .unwrap();
 
         let result = sender.send(email).await;
-        println!("{:?}", result);
+        println!("{result:?}");
         assert!(result.is_ok());
     }
 }
@@ -68,7 +68,7 @@ mod asyncstd_1 {
             .unwrap();
 
         let result = sender.send(email).await;
-        println!("{:?}", result);
+        println!("{result:?}");
         assert!(result.is_ok());
     }
 }

tests/transport_smtp.rs

@@ -24,7 +24,6 @@ mod sync {
 #[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]

tests/transport_smtp_pool.rs

@@ -1,8 +1,9 @@
-#[cfg(all(test, feature = "smtp-transport", feature = "r2d2"))]
+#[cfg(all(test, feature = "smtp-transport", feature = "pool"))]
 mod sync {
-    use lettre::{address::Envelope, SmtpTransport, Transport};
     use std::{sync::mpsc, thread};
 
+    use lettre::{address::Envelope, SmtpTransport, Transport};
+
     fn envelope() -> Envelope {
         Envelope::new(
             Some("user@localhost".parse().unwrap()),

tests/transport_stub.rs

@@ -17,20 +17,25 @@ mod sync {
 
         sender_ok.send(&email).unwrap();
         sender_ko.send(&email).unwrap_err();
+
+        let expected_messages = [(
+            email.envelope().clone(),
+            String::from_utf8(email.formatted()).unwrap(),
+        )];
+        assert_eq!(sender_ok.messages(), expected_messages);
     }
 }
 
 #[cfg(test)]
 #[cfg(all(feature = "builder", feature = "tokio1"))]
 mod tokio_1 {
-    use lettre::{transport::stub::StubTransport, AsyncTransport, Message};
-
+    use lettre::{transport::stub::AsyncStubTransport, AsyncTransport, Message};
     use tokio1_crate as tokio;
 
     #[tokio::test]
     async fn stub_transport_tokio1() {
-        let sender_ok = StubTransport::new_ok();
-        let sender_ko = StubTransport::new_error();
+        let sender_ok = AsyncStubTransport::new_ok();
+        let sender_ko = AsyncStubTransport::new_error();
         let email = Message::builder()
             .from("NoBody <nobody@domain.tld>".parse().unwrap())
             .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
@@ -40,19 +45,25 @@ mod tokio_1 {
             .unwrap();
 
         sender_ok.send(email.clone()).await.unwrap();
-        sender_ko.send(email).await.unwrap_err();
+        sender_ko.send(email.clone()).await.unwrap_err();
+
+        let expected_messages = [(
+            email.envelope().clone(),
+            String::from_utf8(email.formatted()).unwrap(),
+        )];
+        assert_eq!(sender_ok.messages().await, expected_messages);
     }
 }
 
 #[cfg(test)]
 #[cfg(all(feature = "builder", feature = "async-std1"))]
 mod asyncstd_1 {
-    use lettre::{transport::stub::StubTransport, AsyncTransport, Message};
+    use lettre::{transport::stub::AsyncStubTransport, AsyncTransport, Message};
 
     #[async_std::test]
     async fn stub_transport_asyncstd1() {
-        let sender_ok = StubTransport::new_ok();
-        let sender_ko = StubTransport::new_error();
+        let sender_ok = AsyncStubTransport::new_ok();
+        let sender_ko = AsyncStubTransport::new_error();
         let email = Message::builder()
             .from("NoBody <nobody@domain.tld>".parse().unwrap())
             .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
@@ -62,6 +73,12 @@ mod asyncstd_1 {
             .unwrap();
 
         sender_ok.send(email.clone()).await.unwrap();
-        sender_ko.send(email).await.unwrap_err();
+        sender_ko.send(email.clone()).await.unwrap_err();
+
+        let expected_messages = [(
+            email.envelope().clone(),
+            String::from_utf8(email.formatted()).unwrap(),
+        )];
+        assert_eq!(sender_ok.messages().await, expected_messages);
     }
 }