Prepare v0.11.13 (#1044)

Support WASM environments by using web-time.
This was tested on a Cloudflare worker environment.

.github/workflows/test.yml

@@ -13,16 +13,16 @@ env:
 
 jobs:
   rustfmt:
-    name: rustfmt / nightly-2023-06-22
+    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 default nightly-2023-06-22
+          rustup default nightly-2024-09-01
           rustup component add rustfmt
 
       - name: cargo fmt
@@ -34,7 +34,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - name: Install rust
         run: |
@@ -50,7 +50,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - name: Install rust
         run: rustup update --no-self-update stable
@@ -75,12 +75,12 @@ jobs:
             rust: stable
           - name: beta
             rust: beta
-          - name: 1.65.0
+          - name: '1.71'
-            rust: 1.65.0
+            rust: '1.71'
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - name: Install rust
         run: |
@@ -112,12 +112,6 @@ jobs:
       - name: Install dkimverify
         run: sudo apt -y install python3-dkim
 
-      - name: Work around early dependencies MSRV bump
-        run: |
-          cargo update -p anstyle --precise 1.0.2
-          cargo update -p clap --precise 4.3.24
-          cargo update -p clap_lex --precise 0.5.0
-
       - name: Test with no default features
         run: cargo test --no-default-features
 
@@ -134,7 +128,7 @@ jobs:
 #    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,5 +1,233 @@
+<a name="v0.11.13"></a>
+### v0.11.13 (2025-02-17)
+
+#### Features
+
+* Add WASM support ([#1037], [#1042])
+* Add method to get the TLS verify result with BoringSSL ([#1039])
+
+#### Bug fixes
+
+* Synchronous pool shutdowns being arbitrarily delayed ([#1041])
+
+[#1037]: https://github.com/lettre/lettre/pull/1037
+[#1039]: https://github.com/lettre/lettre/pull/1039
+[#1041]: https://github.com/lettre/lettre/pull/1041
+[#1042]: https://github.com/lettre/lettre/pull/1042
+
+<a name="v0.11.12"></a>
+### v0.11.12 (2025-02-02)
+
+#### Misc
+
+* Warn against manually configuring `port` and `tls` on SMTP transport builder ([#1014])
+* Document variants of `Tls` enum ([#1015])
+* Fix rustdoc warnings ([#1016])
+* Add `ContentType::TEXT_PLAIN` to `Message` builder examples ([#1017])
+* Document `SmtpTransport` and `AsyncSmtpTransport` ([#1018])
+* Fix typo in transport builder `credentials` method ([#1019])
+* Document required system dependencies for OpenSSL ([#1030])
+* Improve docs for the `transport::smtp` module ([#1031])
+* Improve docs for smtp transport builder `from_url` ([#1032])
+* Replace `assert!` with `?` on `send` examples ([#1033])
+* Warn on more pedantic clippy lints and fix them ([#1035], [#1036])
+
+[#1014]: https://github.com/lettre/lettre/pull/1014
+[#1015]: https://github.com/lettre/lettre/pull/1015
+[#1016]: https://github.com/lettre/lettre/pull/1016
+[#1017]: https://github.com/lettre/lettre/pull/1017
+[#1018]: https://github.com/lettre/lettre/pull/1018
+[#1019]: https://github.com/lettre/lettre/pull/1019
+[#1030]: https://github.com/lettre/lettre/pull/1030
+[#1031]: https://github.com/lettre/lettre/pull/1031
+[#1032]: https://github.com/lettre/lettre/pull/1032
+[#1033]: https://github.com/lettre/lettre/pull/1033
+[#1035]: https://github.com/lettre/lettre/pull/1035
+[#1036]: https://github.com/lettre/lettre/pull/1036
+
+<a name="v0.11.11"></a>
+### v0.11.11 (2024-12-05)
+
+#### Upgrade notes
+
+* MSRV is now 1.71 ([#1008])
+
+#### Bug fixes
+
+* Fix off-by-one error reaching the minimum number of configured pooled connections ([#1012])
+
+#### Misc
+
+* Fix clippy warnings ([#1009])
+* Fix `-Zminimal-versions` build ([#1007])
+
+[#1007]: https://github.com/lettre/lettre/pull/1007
+[#1008]: https://github.com/lettre/lettre/pull/1008
+[#1009]: https://github.com/lettre/lettre/pull/1009
+[#1012]: https://github.com/lettre/lettre/pull/1012
+
+<a name="v0.11.10"></a>
+### v0.11.10 (2024-10-23)
+
+#### Bug fixes
+
+* Ignore disconnect errors when `pool` feature of SMTP transport is disabled ([#999])
+* Use case insensitive comparisons for matching login challenge requests ([#1000])
+
+[#999]: https://github.com/lettre/lettre/pull/999
+[#1000]: https://github.com/lettre/lettre/pull/1000
+
+<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-08-15)
+### 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`.
@@ -189,7 +417,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>

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.11.0"
+version = "0.11.13"
 description = "Email client"
 readme = "README.md"
 homepage = "https://lettre.rs"
@@ -11,7 +11,7 @@ authors = ["Alexis Mousset <contact@amousset.me>", "Paolo Barbolini <paolo@paolo
 categories = ["email", "network-programming"]
 keywords = ["email", "smtp", "mailer", "message", "sendmail"]
 edition = "2021"
-rust-version = "1.65"
+rust-version = "1.71"
 
 [badges]
 is-it-maintained-issue-resolution = { repository = "lettre/lettre" }
@@ -20,8 +20,7 @@ maintenance = { status = "actively-developed" }
 
 [dependencies]
 chumsky = "0.9"
-idna = "0.4"
+idna = "1"
-once_cell = { version = "1", optional = true }
 tracing = { version = "0.1.16", default-features = false, features = ["std"], optional = true } # feature
 
 # builder
@@ -29,8 +28,8 @@ httpdate = { version = "1", optional = true }
 mime = { version = "0.3.4", optional = true }
 fastrand = { version = "2.0", optional = true }
 quoted_printable = { version = "0.5", optional = true }
-base64 = { version = "0.21", optional = true }
+base64 = { version = "0.22", optional = true }
-email-encoding = { version = "0.2", optional = true }
+email-encoding = { version = "0.3", optional = true }
 
 # file transport
 uuid = { version = "1", features = ["v4"], optional = true }
@@ -39,17 +38,19 @@ serde_json = { version = "1", optional = true }
 
 # smtp-transport
 nom = { version = "7", optional = true }
-hostname = { version = "0.3", optional = true } # feature
+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.5", optional = true } # feature
+native-tls = { version = "0.2.9", optional = true } # feature
-rustls = { version = "0.21", features = ["dangerous_configuration"], optional = true }
+rustls = { version = "0.23.5", default-features = false, features = ["ring", "logging", "std", "tls12"], optional = true }
-rustls-pemfile = { version = "1", optional = true }
+rustls-pemfile = { version = "2", optional = true }
-rustls-native-certs = { version = "0.6.2", optional = true }
+rustls-native-certs = { version = "0.8", optional = true }
-webpki-roots = { version = "0.25", optional = true }
+rustls-pki-types = { version = "1.7", optional = true }
-boring = { version = "3", optional = true }
+webpki-roots = { version = "0.26", optional = true }
+boring = { version = "4", optional = true }
 
 # async
 futures-io = { version = "0.3.7", optional = true }
@@ -58,14 +59,13 @@ async-trait = { version = "0.1", optional = true }
 
 ## async-std
 async-std = { version = "1.8", optional = true }
-#async-native-tls = { version = "0.3.3", optional = true }
+futures-rustls = { version = "0.26", default-features = false, features = ["logging", "tls12", "ring"], optional = true }
-futures-rustls = { version = "0.24", optional = true }
 
 ## tokio
 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.24", 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 = "3", optional = true }
+tokio1_boring = { package = "tokio-boring", version = "4", optional = true }
 
 ## dkim
 sha2 = { version = "0.10", optional = true, features = ["oid"] }
@@ -75,6 +75,9 @@ ed25519-dalek = { version = "2", optional = true }
 # email formats
 email_address = { version = "0.2.1", default-features = false }
 
+# webtime for wasm support
+web-time = { version = "1.1.0", optional = true }
+
 [dev-dependencies]
 pretty_assertions = "1"
 criterion = "0.5"
@@ -85,7 +88,7 @@ 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.25"
+maud = "0.26"
 
 [[bench]]
 harness = false
@@ -104,17 +107,16 @@ mime03 = ["dep:mime"]
 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:once_cell", "dep:url", "tokio1_crate?/rt", "tokio1_crate?/time", "tokio1_crate?/net"]
+smtp-transport = ["dep:base64", "dep:nom", "dep:socket2", "dep:url", "dep:percent-encoding", "tokio1_crate?/rt", "tokio1_crate?/time", "tokio1_crate?/net"]
 
 pool = ["dep:futures-util"]
 
-rustls-tls = ["dep:webpki-roots", "dep:rustls", "dep:rustls-pemfile"]
+rustls-tls = ["dep:webpki-roots", "dep:rustls", "dep:rustls-pemfile", "dep:rustls-pki-types"]
 
 boring-tls = ["dep:boring"]
 
 # async
 async-std1 = ["dep:async-std", "dep:async-trait", "dep:futures-io", "dep:futures-util"]
-#async-std1-native-tls = ["async-std1", "native-tls", "dep:async-native-tls"]
 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"]
@@ -123,6 +125,12 @@ tokio1-boring-tls = ["tokio1", "boring-tls", "dep:tokio1_boring"]
 
 dkim = ["dep:base64", "dep:sha2", "dep:rsa", "dep:ed25519-dalek"]
 
+# wasm support
+web = ["dep:web-time"]
+
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(lettre_ignore_tls_mismatch)'] }
+
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs", "--cfg", "lettre_ignore_tls_mismatch"]

LICENSE

@@ -1,5 +1,5 @@
-Copyright (c) 2014-2022 Alexis Mousset <contact@amousset.me>
+Copyright (c) 2014-2024 Alexis Mousset <contact@amousset.me>
-Copyright (c) 2019-2022 Paolo Barbolini <paolo@paolo565.org>
+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,8 +28,8 @@
 </div>
 
 <div align="center">
-  <a href="https://deps.rs/crate/lettre/0.11.0">
+  <a href="https://deps.rs/crate/lettre/0.11.13">
-    <img src="https://deps.rs/crate/lettre/0.11.0/status.svg"
+    <img src="https://deps.rs/crate/lettre/0.11.13/status.svg"
       alt="dependency status" />
   </a>
 </div>
@@ -53,12 +53,12 @@ Lettre does not provide (for now):
 ## 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.65, but this could change at any time either from
+the minimum supported Rust version is 1.71, 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.65 or newer.
+This library requires Rust 1.71 or newer.
 To use this library, add the following to your `Cargo.toml`:
 
 ```toml
@@ -71,27 +71,29 @@ use lettre::message::header::ContentType;
 use lettre::transport::smtp::authentication::Credentials;
 use lettre::{Message, SmtpTransport, Transport};
 
-let email = Message::builder()
+fn main() {
-    .from("NoBody <nobody@domain.tld>".parse().unwrap())
+    let email = Message::builder()
-    .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
+        .from("NoBody <nobody@domain.tld>".parse().unwrap())
-    .to("Hei <hei@domain.tld>".parse().unwrap())
+        .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-    .subject("Happy new year")
+        .to("Hei <hei@domain.tld>".parse().unwrap())
-    .header(ContentType::TEXT_PLAIN)
+        .subject("Happy new year")
-    .body(String::from("Be happy!"))
+        .header(ContentType::TEXT_PLAIN)
-    .unwrap();
+        .body(String::from("Be happy!"))
+        .unwrap();
 
-let creds = Credentials::new("smtp_username".to_owned(), "smtp_password".to_owned());
+    let creds = Credentials::new("smtp_username".to_owned(), "smtp_password".to_owned());
 
-// Open a remote connection to gmail
+    // Open a remote connection to gmail
-let mailer = SmtpTransport::relay("smtp.gmail.com")
+    let mailer = SmtpTransport::relay("smtp.gmail.com")
-    .unwrap()
+        .unwrap()
-    .credentials(creds)
+        .credentials(creds)
-    .build();
+        .build();
 
-// Send the email
+    // Send the email
-match mailer.send(&email) {
+    match mailer.send(&email) {
-    Ok(_) => println!("Email sent successfully!"),
+        Ok(_) => println!("Email sent successfully!"),
-    Err(e) => panic!("Could not send email: {e:?}"),
+        Err(e) => panic!("Could not send email: {e:?}"),
+    }
 }
 ```
 

benches/transport_smtp.rs

@@ -1,5 +1,5 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use lettre::{Message, SmtpTransport, Transport};
+use lettre::{message::header::ContentType, Message, SmtpTransport, Transport};
 
 fn bench_simple_send(c: &mut Criterion) {
     let sender = SmtpTransport::builder_dangerous("127.0.0.1")
@@ -13,6 +13,7 @@ fn bench_simple_send(c: &mut Criterion) {
                 .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
                 .to("Hei <hei@domain.tld>".parse().unwrap())
                 .subject("Happy new year")
+                .header(ContentType::TEXT_PLAIN)
                 .body(String::from("Be happy!"))
                 .unwrap();
             let result = black_box(sender.send(&email));
@@ -32,6 +33,7 @@ fn bench_reuse_send(c: &mut Criterion) {
                 .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
                 .to("Hei <hei@domain.tld>".parse().unwrap())
                 .subject("Happy new year")
+                .header(ContentType::TEXT_PLAIN)
                 .body(String::from("Be happy!"))
                 .unwrap();
             let result = black_box(sender.send(&email));

examples/autoconfigure.rs

@@ -41,7 +41,7 @@ fn main() {
 
     // Plaintext connection which MUST then successfully upgrade to TLS via STARTTLS
     {
-        tracing::info!("Trying to establish a plaintext connection to {} and then updating it via the SMTP STARTTLS extension", smtp_host);
+        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")

src/address/envelope.rs

@@ -14,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/serde.rs

@@ -36,7 +36,7 @@ impl<'de> Deserialize<'de> for Address {
             {
                 struct FieldVisitor;
 
-                impl<'de> Visitor<'de> for FieldVisitor {
+                impl Visitor<'_> for FieldVisitor {
                     type Value = Field;
 
                     fn expecting(&self, formatter: &mut Formatter<'_>) -> FmtResult {

src/executor.rs

@@ -134,7 +134,7 @@ impl Executor for Tokio1Executor {
         #[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)]
@@ -149,12 +149,12 @@ impl Executor for Tokio1Executor {
 
         #[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?;
             }
             _ => (),
@@ -230,8 +230,8 @@ impl Executor for AsyncStd1Executor {
     ) -> 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"))]
+            #[cfg(feature = "async-std1-rustls-tls")]
-            Tls::Wrapper(ref tls_parameters) => Some(tls_parameters.clone()),
+            Tls::Wrapper(tls_parameters) => Some(tls_parameters.clone()),
             _ => None,
         };
         #[allow(unused_mut)]
@@ -243,14 +243,14 @@ impl Executor for AsyncStd1Executor {
         )
         .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?;
             }
             _ => (),

src/lib.rs

@@ -6,7 +6,7 @@
 //! * Secure defaults
 //! * Async support
 //!
-//! Lettre requires Rust 1.65 or newer.
+//! Lettre requires Rust 1.71 or newer.
 //!
 //! ## Features
 //!
@@ -34,13 +34,25 @@
 //!
 //! _Secure SMTP connections using TLS from the `native-tls` crate_
 //!
-//! Uses schannel on Windows, Security-Framework on macOS, and OpenSSL on Linux.
+//! Uses schannel on Windows, Security-Framework on macOS, and OpenSSL
+//! on all other platforms.
 //!
 //! * **native-tls** 📫: TLS support for the synchronous version of the API
 //! * **tokio1-native-tls**: TLS support for the `tokio1` async version of the API
 //!
 //! NOTE: native-tls isn't supported with `async-std`
 //!
+//! ##### Building lettre with OpenSSL
+//!
+//! When building lettre with native-tls on a system that makes
+//! use of OpenSSL, the following packages will need to be installed
+//! in order for the build and the compiled program to run properly.
+//!
+//! | Distro       | Build-time packages        | Runtime packages             |
+//! | ------------ | -------------------------- | ---------------------------- |
+//! | Debian       | `pkg-config`, `libssl-dev` | `libssl3`, `ca-certificates` |
+//! | Alpine Linux | `pkgconf`, `openssl-dev`   | `libssl3`, `ca-certificates` |
+//!
 //! #### SMTP over TLS via the boring crate (Boring TLS)
 //!
 //! _Secure SMTP connections using TLS from the `boring-tls` crate_
@@ -95,6 +107,7 @@
 //! * **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
+//! * **web**: WebAssembly support using the `web-time` crate for time operations
 //!
 //! [`SMTP`]: crate::transport::smtp
 //! [`sendmail`]: crate::transport::sendmail
@@ -109,7 +122,7 @@
 //! [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.11.0")]
+#![doc(html_root_url = "https://docs.rs/crate/lettre/0.11.13")]
 #![doc(html_favicon_url = "https://lettre.rs/favicon.ico")]
 #![doc(html_logo_url = "https://avatars0.githubusercontent.com/u/15113230?v=4")]
 #![forbid(unsafe_code)]
@@ -137,7 +150,14 @@
     clippy::wildcard_imports,
     clippy::str_to_string,
     clippy::empty_structs_with_brackets,
-    clippy::zero_sized_map_values
+    clippy::zero_sized_map_values,
+    clippy::manual_let_else,
+    clippy::semicolon_if_nothing_returned,
+    clippy::unnecessary_wraps,
+    clippy::doc_markdown,
+    clippy::explicit_iter_loop,
+    clippy::redundant_closure_for_method_calls,
+    // Rust 1.86: clippy::unnecessary_semicolon,
 )]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 
@@ -174,21 +194,7 @@ mod compiletime_checks {
     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",))]
-    #[cfg(all(
-        feature = "async-std1",
-        feature = "native-tls",
-        not(feature = "async-std1-native-tls")
-    ))]
-    compile_error!("Lettre is being built with the `async-std1` and the `native-tls` features, but the `async-std1-native-tls` feature hasn't been turned on.
-    If you'd like to use rustls make sure that the `native-tls` hasn't been enabled by mistake (you may need to import lettre without default features)
-    If you're building a library which depends on lettre import it without default features and enable just the features you need.");
-    */
-    #[cfg(all(
-        feature = "async-std1",
-        feature = "native-tls",
-        not(feature = "async-std1-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.
@@ -213,6 +219,7 @@ mod executor;
 #[cfg(feature = "builder")]
 #[cfg_attr(docsrs, doc(cfg(feature = "builder")))]
 pub mod message;
+mod time;
 pub mod transport;
 
 use std::error::Error as StdError;

src/message/dkim.rs

@@ -2,7 +2,6 @@ use std::{
     borrow::Cow,
     error::Error as StdError,
     fmt::{self, Display},
-    iter::IntoIterator,
     time::SystemTime,
 };
 
@@ -70,7 +69,7 @@ impl Display for DkimSigningAlgorithm {
     }
 }
 
-/// Describe DkimSigning key error
+/// Describe [`DkimSigningKey`] key error
 #[derive(Debug)]
 pub struct DkimSigningKeyError(InnerDkimSigningKeyError);
 
@@ -101,7 +100,7 @@ impl StdError for DkimSigningKeyError {
     }
 }
 
-/// Describe a signing key to be carried by DkimConfig struct
+/// Describe a signing key to be carried by [`DkimConfig`] struct
 #[derive(Debug)]
 pub struct DkimSigningKey(InnerDkimSigningKey);
 
@@ -184,7 +183,7 @@ impl DkimConfig {
         }
     }
 
-    /// Create a DkimConfig
+    /// Create a [`DkimConfig`]
     pub fn new(
         selector: String,
         domain: String,
@@ -284,19 +283,19 @@ fn dkim_canonicalize_headers_relaxed(headers: &str) -> String {
             // End of header.
             [b'\r', b'\n', ..] => {
                 *out += "\r\n";
-                name(&h[2..], out)
+                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)
+                value(&h[1..], out);
             }
             [_, ..] => {
                 let mut chars = h.chars();
                 out.push(chars.next().unwrap());
-                value(chars.as_str(), out)
+                value(chars.as_str(), out);
             }
             [] => {}
         }
@@ -318,7 +317,7 @@ fn dkim_canonicalize_header_tag(
     }
 }
 
-/// Canonicalize signed headers passed as headers_list among mail_headers using canonicalization
+/// 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,
@@ -345,10 +344,12 @@ fn dkim_canonicalize_headers<'a>(
 }
 
 /// Sign with Dkim a message by adding Dkim-Signature header created with configuration expressed by
-/// dkim_config
+/// `dkim_config`
-
 pub fn dkim_sign(message: &mut Message, dkim_config: &DkimConfig) {
-    dkim_sign_fixed_time(message, dkim_config, SystemTime::now())
+    #[cfg(feature = "web")]
+    dkim_sign_fixed_time(message, dkim_config, crate::time::now());
+    #[cfg(not(feature = "web"))]
+    dkim_sign_fixed_time(message, dkim_config, SystemTime::now());
 }
 
 fn dkim_sign_fixed_time(message: &mut Message, dkim_config: &DkimConfig, timestamp: SystemTime) {
@@ -379,7 +380,7 @@ fn dkim_sign_fixed_time(message: &mut Message, dkim_config: &DkimConfig, timesta
     }
     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()),
+        dkim_config.headers.iter().map(AsRef::as_ref),
         headers,
         dkim_config.canonicalization.header,
     );
@@ -489,14 +490,14 @@ cJ5Ku0OTwRtSMaseRPX+T4EfG1Caa/eunPPN4rh+CSup2BVVarOT
     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")
+        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")
+        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]

src/message/header/content_disposition.rs

@@ -1,6 +1,6 @@
 use std::fmt::Write;
 
-use email_encoding::headers::EmailWriter;
+use email_encoding::headers::writer::EmailWriter;
 
 use super::{Header, HeaderName, HeaderValue};
 use crate::BoxError;
@@ -38,10 +38,10 @@ impl ContentDisposition {
         let mut encoded_value = String::new();
         let line_len = "Content-Disposition: ".len();
         {
-            let mut w = EmailWriter::new(&mut encoded_value, line_len, 0, false, false);
+            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.optional_breakpoint();
+            w.space();
 
             email_encoding::headers::rfc2231::encode("filename", file_name, &mut w)
                 .expect("some Write implementation returned an error");

src/message/header/content_type.rs

@@ -119,7 +119,7 @@ mod serde {
         {
             struct ContentTypeVisitor;
 
-            impl<'de> Visitor<'de> for ContentTypeVisitor {
+            impl Visitor<'_> for ContentTypeVisitor {
                 type Value = ContentType;
 
                 // The error message which states what the Visitor expects to

src/message/header/date.rs

@@ -21,7 +21,7 @@ impl Date {
     ///
     /// Shortcut for `Date::new(SystemTime::now())`
     pub fn now() -> Self {
-        Self::new(SystemTime::now())
+        Self::new(crate::time::now())
     }
 }
 

src/message/header/mailbox.rs

@@ -1,4 +1,4 @@
-use email_encoding::headers::EmailWriter;
+use email_encoding::headers::writer::EmailWriter;
 
 use super::{Header, HeaderName, HeaderValue};
 use crate::{
@@ -31,7 +31,7 @@ macro_rules! mailbox_header {
                 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, false);
+                    let mut w = EmailWriter::new(&mut encoded_value, line_len, 0, false);
                     self.0.encode(&mut w).expect("writing `Mailbox` returned an error");
                 }
 
@@ -81,7 +81,7 @@ macro_rules! mailboxes_header {
                 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, false);
+                    let mut w = EmailWriter::new(&mut encoded_value, line_len, 0, false);
                     self.0.encode(&mut w).expect("writing `Mailboxes` returned an error");
                 }
 
@@ -110,7 +110,7 @@ mailbox_header! {
 
     `Sender` header
 
-    This header contains [`Mailbox`][self::Mailbox] associated with sender.
+    This header contains [`Mailbox`] associated with sender.
 
     ```no_test
     header::Sender("Mr. Sender <sender@example.com>".parse().unwrap())
@@ -124,7 +124,7 @@ mailboxes_header! {
 
     `From` header
 
-    This header contains [`Mailboxes`][self::Mailboxes].
+    This header contains [`Mailboxes`].
 
      */
     (From, "From")
@@ -135,7 +135,7 @@ mailboxes_header! {
 
     `Reply-To` header
 
-    This header contains [`Mailboxes`][self::Mailboxes].
+    This header contains [`Mailboxes`].
 
      */
     (ReplyTo, "Reply-To")
@@ -146,7 +146,7 @@ mailboxes_header! {
 
     `To` header
 
-    This header contains [`Mailboxes`][self::Mailboxes].
+    This header contains [`Mailboxes`].
 
      */
     (To, "To")
@@ -157,7 +157,7 @@ mailboxes_header! {
 
     `Cc` header
 
-    This header contains [`Mailboxes`][self::Mailboxes].
+    This header contains [`Mailboxes`].
 
      */
     (Cc, "Cc")
@@ -168,7 +168,7 @@ mailboxes_header! {
 
     `Bcc` header
 
-    This header contains [`Mailboxes`][self::Mailboxes].
+    This header contains [`Mailboxes`].
 
      */
     (Bcc, "Bcc")

src/message/header/mod.rs

@@ -7,7 +7,7 @@ use std::{
     ops::Deref,
 };
 
-use email_encoding::headers::EmailWriter;
+use email_encoding::headers::writer::EmailWriter;
 
 pub use self::{
     content::*,
@@ -124,22 +124,18 @@ impl Headers {
     }
 
     pub(crate) fn find_header(&self, name: &str) -> Option<&HeaderValue> {
-        self.headers
+        self.headers.iter().find(|value| name == value.name)
-            .iter()
-            .find(|value| name.eq_ignore_ascii_case(&value.name))
     }
 
     fn find_header_mut(&mut self, name: &str) -> Option<&mut HeaderValue> {
-        self.headers
+        self.headers.iter_mut().find(|value| name == value.name)
-            .iter_mut()
-            .find(|value| name.eq_ignore_ascii_case(&value.name))
     }
 
     fn find_header_index(&self, name: &str) -> Option<usize> {
         self.headers
             .iter()
             .enumerate()
-            .find(|(_i, value)| name.eq_ignore_ascii_case(&value.name))
+            .find(|(_i, value)| name == value.name)
             .map(|(i, _)| i)
     }
 }
@@ -161,18 +157,9 @@ impl Display for Headers {
 /// A possible error when converting a `HeaderName` from another type.
 // comes from `http` crate
 #[allow(missing_copy_implementations)]
-#[derive(Clone)]
+#[derive(Debug, Clone)]
-pub struct InvalidHeaderName {
+#[non_exhaustive]
-    _priv: (),
+pub struct InvalidHeaderName;
-}
-
-impl fmt::Debug for InvalidHeaderName {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("InvalidHeaderName")
-            // skip _priv noise
-            .finish()
-    }
-}
 
 impl fmt::Display for InvalidHeaderName {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -189,14 +176,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()
+        if !ascii.is_empty() && ascii.len() <= 76 && ascii.is_ascii() && !ascii.contains([':', ' '])
-            && ascii.len() <= 76
-            && ascii.is_ascii()
-            && !ascii.contains(|c| c == ':' || c == ' ')
         {
             Ok(Self(Cow::Owned(ascii)))
         } else {
-            Err(InvalidHeaderName { _priv: () })
+            Err(InvalidHeaderName)
         }
     }
 
@@ -257,23 +241,19 @@ impl AsRef<str> for HeaderName {
 
 impl PartialEq<HeaderName> for HeaderName {
     fn eq(&self, other: &HeaderName) -> bool {
-        let s1: &str = self.as_ref();
+        self.eq_ignore_ascii_case(other)
-        let s2: &str = other.as_ref();
-        s1 == s2
     }
 }
 
 impl PartialEq<&str> for HeaderName {
     fn eq(&self, other: &&str) -> bool {
-        let s: &str = self.as_ref();
+        self.eq_ignore_ascii_case(other)
-        s == *other
     }
 }
 
 impl PartialEq<HeaderName> for &str {
     fn eq(&self, other: &HeaderName) -> bool {
-        let s: &str = other.as_ref();
+        self.eq_ignore_ascii_case(other)
-        *self == s
     }
 }
 
@@ -348,7 +328,7 @@ impl<'a> HeaderValueEncoder<'a> {
 
     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, false);
+        let writer = EmailWriter::new(writer, line_len, 0, false);
 
         Self {
             writer,
@@ -435,7 +415,7 @@ mod tests {
 
     #[test]
     fn empty_headername() {
-        assert!(HeaderName::new_from_ascii(String::from("")).is_err());
+        assert!(HeaderName::new_from_ascii("".to_owned()).is_err());
     }
 
     #[test]
@@ -467,6 +447,60 @@ 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]
@@ -612,17 +646,14 @@ mod tests {
             "🌍 <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(),
         ));
 
-        // TODO: fix the fact that the encoder doesn't know that
-        // the space between the name and the address should be
-        // removed when wrapping.
         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>,\r\n",
+                " =?utf-8?b?SsSBbmlzIELEk3J6acWGxaE=?= <janis@example.com>, =?utf-8?b?U2U=?=\r\n",
-                "  =?utf-8?b?U2XDoW4gw5MgUnVkYcOt?= <sean@example.com>\r\n",
+                " =?utf-8?b?w6FuIMOTIFJ1ZGHDrQ==?= <sean@example.com>\r\n",
             )
         );
     }
@@ -687,9 +718,6 @@ mod tests {
             "quoted-printable".to_owned(),
         ));
 
-        // TODO: fix the fact that the encoder doesn't know that
-        // the space between the name and the address should be
-        // removed when wrapping.
         assert_eq!(
             headers.to_string(),
             concat!(
@@ -699,8 +727,8 @@ mod tests {
                 "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>,\r\n",
+                " =?utf-8?b?SsSBbmlzIELEk3J6acWGxaE=?= <janis@example.com>, =?utf-8?b?U2U=?=\r\n",
-                "  =?utf-8?b?U2XDoW4gw5MgUnVkYcOt?= <sean@example.com>\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",
             )

src/message/mailbox/parsers/rfc2822.rs

@@ -170,7 +170,9 @@ fn phrase() -> impl Parser<char, Vec<char>, Error = Cheap<char>> {
 // 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)))).then_ignore(end())
+    choice((name_addr(), addr_spec().map(|addr| (None, addr))))
+        .padded()
+        .then_ignore(end())
 }
 
 // name-addr       =       [display-name] angle-addr

src/message/mailbox/serde.rs

@@ -36,7 +36,7 @@ impl<'de> Deserialize<'de> for Mailbox {
             {
                 struct FieldVisitor;
 
-                impl<'de> Visitor<'de> for FieldVisitor {
+                impl Visitor<'_> for FieldVisitor {
                     type Value = Field;
 
                     fn expecting(&self, formatter: &mut Formatter<'_>) -> FmtResult {

src/message/mailbox/types.rs

@@ -6,7 +6,7 @@ use std::{
 };
 
 use chumsky::prelude::*;
-use email_encoding::headers::EmailWriter;
+use email_encoding::headers::writer::EmailWriter;
 
 use super::parsers;
 use crate::address::{Address, AddressError};
@@ -72,7 +72,7 @@ impl Mailbox {
     pub(crate) fn encode(&self, w: &mut EmailWriter<'_>) -> FmtResult {
         if let Some(name) = &self.name {
             email_encoding::headers::quoted_string::encode(name, w)?;
-            w.optional_breakpoint();
+            w.space();
             w.write_char('<')?;
         }
 
@@ -88,7 +88,7 @@ impl Mailbox {
 
 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() {
                 write_word(f, name)?;
@@ -174,7 +174,7 @@ impl Mailboxes {
         self
     }
 
-    /// Adds a new [`Mailbox`] to the list, in a Vec::push style pattern.
+    /// Adds a new [`Mailbox`] to the list, in a `Vec::push` style pattern.
     ///
     /// # Examples
     ///
@@ -261,7 +261,7 @@ impl Mailboxes {
         for mailbox in self.iter() {
             if !mem::take(&mut first) {
                 w.write_char(',')?;
-                w.optional_breakpoint();
+                w.space();
             }
 
             mailbox.encode(w)?;
@@ -351,7 +351,7 @@ impl FromStr for Mailboxes {
         })?;
 
         for (name, (user, domain)) in parsed_mailboxes {
-            mailboxes.push(Mailbox::new(name, Address::new(user, domain)?))
+            mailboxes.push(Mailbox::new(name, Address::new(user, domain)?));
         }
 
         Ok(Mailboxes(mailboxes))
@@ -444,8 +444,6 @@ fn write_quoted_string_char(f: &mut Formatter<'_>, c: char) -> FmtResult {
 
 #[cfg(test)]
 mod test {
-    use std::convert::TryInto;
-
     use pretty_assertions::assert_eq;
 
     use super::Mailbox;
@@ -533,7 +531,7 @@ mod test {
         assert_eq!(
             format!(
                 "{}",
-                Mailbox::new(Some("".into()), "kayo@example.com".parse().unwrap())
+                Mailbox::new(Some("".to_owned()), "kayo@example.com".parse().unwrap())
             ),
             "kayo@example.com"
         );
@@ -558,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!(
@@ -569,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!(
@@ -580,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()))
         );
     }

src/message/mimebody.rs

@@ -17,6 +17,16 @@ 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>) {
         match self {
@@ -132,6 +142,12 @@ impl SinglePart {
         self.format(&mut out);
         out
     }
+
+    /// Format only the signlepart body
+    fn format_body(&self, out: &mut Vec<u8>) {
+        out.extend_from_slice(&self.body);
+        out.extend_from_slice(b"\r\n");
+    }
 }
 
 impl EmailFormat for SinglePart {
@@ -139,8 +155,7 @@ impl EmailFormat for SinglePart {
         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);
+        self.format_body(out);
-        out.extend_from_slice(b"\r\n");
     }
 }
 
@@ -373,14 +388,9 @@ impl MultiPart {
         self.format(&mut out);
         out
     }
-}
-
-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");
 
+    /// Format only the multipart body
+    fn format_body(&self, out: &mut Vec<u8>) {
         let boundary = self.boundary();
 
         for part in &self.parts {
@@ -396,12 +406,20 @@ impl EmailFormat for MultiPart {
     }
 }
 
+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");
+        self.format_body(out);
+    }
+}
+
 #[cfg(test)]
 mod test {
     use pretty_assertions::assert_eq;
 
     use super::*;
-    use crate::message::header;
 
     #[test]
     fn single_part_binary() {

src/message/mod.rs

@@ -277,7 +277,7 @@ impl MessageBuilder {
     /// Shortcut for `self.date(SystemTime::now())`, it is automatically inserted
     /// if no date has been provided.
     pub fn date_now(self) -> Self {
-        self.date(SystemTime::now())
+        self.date(crate::time::now())
     }
 
     /// Set or add mailbox to `ReplyTo` header
@@ -345,7 +345,7 @@ impl MessageBuilder {
                 let hostname = hostname::get()
                     .map_err(|_| ())
                     .and_then(|s| s.into_string().map_err(|_| ()))
-                    .unwrap_or_else(|_| DEFAULT_MESSAGE_ID_DOMAIN.to_owned());
+                    .unwrap_or_else(|()| DEFAULT_MESSAGE_ID_DOMAIN.to_owned());
                 #[cfg(not(feature = "hostname"))]
                 let hostname = DEFAULT_MESSAGE_ID_DOMAIN.to_owned();
 
@@ -457,12 +457,12 @@ impl MessageBuilder {
         self.build(MessageBody::Raw(body.into_vec()))
     }
 
-    /// Create message using mime body ([`MultiPart`][self::MultiPart])
+    /// Create message using mime body ([`MultiPart`])
     pub fn multipart(self, part: MultiPart) -> Result<Message, EmailError> {
         self.mime_1_0().build(MessageBody::Mime(Part::Multi(part)))
     }
 
-    /// Create message using mime body ([`SinglePart`][self::SinglePart])
+    /// Create message using mime body ([`SinglePart`])
     pub fn singlepart(self, part: SinglePart) -> Result<Message, EmailError> {
         self.mime_1_0().build(MessageBody::Mime(Part::Single(part)))
     }
@@ -525,9 +525,9 @@ impl Message {
     pub(crate) fn body_raw(&self) -> Vec<u8> {
         let mut out = Vec::new();
         match &self.body {
-            MessageBody::Mime(p) => p.format(&mut out),
+            MessageBody::Mime(p) => p.format_body(&mut out),
             MessageBody::Raw(r) => out.extend_from_slice(r),
-        };
+        }
         out.extend_from_slice(b"\r\n");
         out
     }
@@ -537,7 +537,10 @@ impl Message {
     /// Example:
     /// ```rust
     /// use lettre::{
-    ///     message::dkim::{DkimConfig, DkimSigningAlgorithm, DkimSigningKey},
+    ///     message::{
+    ///         dkim::{DkimConfig, DkimSigningAlgorithm, DkimSigningKey},
+    ///         header::ContentType,
+    ///     },
     ///     Message,
     /// };
     ///
@@ -546,6 +549,7 @@ impl Message {
     ///     .reply_to("Bob <bob@example.org>".parse().unwrap())
     ///     .to("Carla <carla@example.net>".parse().unwrap())
     ///     .subject("Hello")
+    ///     .header(ContentType::TEXT_PLAIN)
     ///     .body("Hi there, it's a test email, with utf-8 chars ë!\n\n\n".to_owned())
     ///     .unwrap();
     /// let key = "-----BEGIN RSA PRIVATE KEY-----
@@ -601,7 +605,7 @@ impl EmailFormat for Message {
             MessageBody::Mime(p) => p.format(out),
             MessageBody::Raw(r) => {
                 out.extend_from_slice(b"\r\n");
-                out.extend_from_slice(r)
+                out.extend_from_slice(r);
             }
         }
     }
@@ -765,7 +769,7 @@ mod test {
                 continue;
             }
 
-            assert_eq!(line.0, line.1)
+            assert_eq!(line.0, line.1);
         }
     }
 

src/time.rs

@@ -0,0 +1,18 @@
+use std::time::SystemTime;
+
+#[cfg(feature = "web")]
+pub(crate) fn now() -> SystemTime {
+    fn to_std_systemtime(time: web_time::SystemTime) -> std::time::SystemTime {
+        let duration = time
+            .duration_since(web_time::SystemTime::UNIX_EPOCH)
+            .unwrap();
+        SystemTime::UNIX_EPOCH + duration
+    }
+
+    to_std_systemtime(web_time::SystemTime::now())
+}
+
+#[cfg(not(feature = "web"))]
+pub(crate) fn now() -> SystemTime {
+    SystemTime::now()
+}

src/transport/file/error.rs

@@ -54,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);
         }
 
@@ -68,9 +68,9 @@ impl fmt::Display for Error {
             Kind::Io => f.write_str("response error")?,
             #[cfg(feature = "file-transport-envelope")]
             Kind::Envelope => f.write_str("internal client error")?,
-        };
+        }
 
-        if let Some(ref e) = self.inner.source {
+        if let Some(e) = &self.inner.source {
             write!(f, ": {e}")?;
         }
 

src/transport/file/mod.rs

@@ -11,7 +11,7 @@
 //! # fn main() -> Result<(), Box<dyn Error>> {
 //! use std::env::temp_dir;
 //!
-//! use lettre::{FileTransport, Message, Transport};
+//! use lettre::{message::header::ContentType, FileTransport, Message, Transport};
 //!
 //! // Write to the local temp directory
 //! let sender = FileTransport::new(temp_dir());
@@ -20,10 +20,10 @@
 //!     .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!"))?;
 //!
-//! let result = sender.send(&email);
+//! sender.send(&email)?;
-//! assert!(result.is_ok());
 //! # Ok(())
 //! # }
 //!
@@ -44,7 +44,7 @@
 //! # fn main() -> Result<(), Box<dyn Error>> {
 //! use std::env::temp_dir;
 //!
-//! use lettre::{FileTransport, Message, Transport};
+//! use lettre::{message::header::ContentType, FileTransport, Message, Transport};
 //!
 //! // Write to the local temp directory
 //! let sender = FileTransport::with_envelope(temp_dir());
@@ -53,10 +53,10 @@
 //!     .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!"))?;
 //!
-//! let result = sender.send(&email);
+//! sender.send(&email)?;
-//! assert!(result.is_ok());
 //! # Ok(())
 //! # }
 //!
@@ -73,7 +73,9 @@
 //! # async fn run() -> Result<(), Box<dyn Error>> {
 //! use std::env::temp_dir;
 //!
-//! use lettre::{AsyncFileTransport, AsyncTransport, Message, Tokio1Executor};
+//! use lettre::{
+//!     message::header::ContentType, AsyncFileTransport, AsyncTransport, Message, Tokio1Executor,
+//! };
 //!
 //! // Write to the local temp directory
 //! let sender = AsyncFileTransport::<Tokio1Executor>::new(temp_dir());
@@ -82,10 +84,10 @@
 //!     .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!"))?;
 //!
-//! let result = sender.send(email).await;
+//! sender.send(email).await?;
-//! assert!(result.is_ok());
 //! # Ok(())
 //! # }
 //! ```
@@ -99,7 +101,10 @@
 //! # async fn run() -> Result<(), Box<dyn Error>> {
 //! use std::env::temp_dir;
 //!
-//! use lettre::{AsyncFileTransport, AsyncStd1Executor, AsyncTransport, Message};
+//! use lettre::{
+//!     message::header::ContentType, AsyncFileTransport, AsyncStd1Executor, AsyncTransport,
+//!     Message,
+//! };
 //!
 //! // Write to the local temp directory
 //! let sender = AsyncFileTransport::<AsyncStd1Executor>::new(temp_dir());
@@ -108,10 +113,10 @@
 //!     .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!"))?;
 //!
-//! let result = sender.send(email).await;
+//! sender.send(email).await?;
-//! assert!(result.is_ok());
 //! # Ok(())
 //! # }
 //! ```
@@ -125,6 +130,7 @@
 //! Reply-To: Yuin <yuin@domain.tld>
 //! To: Hei <hei@domain.tld>
 //! Subject: Happy new year
+//! Content-Type: text/plain; charset=utf-8
 //! Date: Tue, 18 Aug 2020 22:50:17 GMT
 //!
 //! Be happy!
@@ -157,7 +163,7 @@ 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 {
@@ -167,7 +173,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"))]

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,13 +56,17 @@
 //! #
 //! # #[cfg(all(feature = "builder", feature = "smtp-transport"))]
 //! # fn main() -> Result<(), Box<dyn Error>> {
-//! use lettre::{transport::smtp::authentication::Credentials, Message, SmtpTransport, Transport};
+//! use lettre::{
+//!     message::header::ContentType, transport::smtp::authentication::Credentials, Message,
+//!     SmtpTransport, Transport,
+//! };
 //!
 //! let email = Message::builder()
 //!     .from("NoBody <nobody@domain.tld>".parse()?)
 //!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
 //!     .to("Hei <hei@domain.tld>".parse()?)
 //!     .subject("Happy new year")
+//!     .header(ContentType::TEXT_PLAIN)
 //!     .body(String::from("Be happy!"))?;
 //!
 //! let creds = Credentials::new("smtp_username".to_owned(), "smtp_password".to_owned());
@@ -97,6 +101,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;

src/transport/sendmail/error.rs

@@ -52,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);
         }
 
@@ -65,9 +65,9 @@ impl fmt::Display for Error {
         match self.inner.kind {
             Kind::Response => f.write_str("response error")?,
             Kind::Client => f.write_str("internal client error")?,
-        };
+        }
 
-        if let Some(ref e) = self.inner.source {
+        if let Some(e) = &self.inner.source {
             write!(f, ": {e}")?;
         }
 

src/transport/sendmail/mod.rs

@@ -7,18 +7,18 @@
 //! #
 //! # #[cfg(all(feature = "sendmail-transport", feature = "builder"))]
 //! # fn main() -> Result<(), Box<dyn Error>> {
-//! use lettre::{Message, SendmailTransport, Transport};
+//! use lettre::{message::header::ContentType, Message, SendmailTransport, Transport};
 //!
 //! let email = Message::builder()
 //!     .from("NoBody <nobody@domain.tld>".parse()?)
 //!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
 //!     .to("Hei <hei@domain.tld>".parse()?)
 //!     .subject("Happy new year")
+//!     .header(ContentType::TEXT_PLAIN)
 //!     .body(String::from("Be happy!"))?;
 //!
 //! let sender = SendmailTransport::new();
-//! let result = sender.send(&email);
+//! sender.send(&email)?;
-//! assert!(result.is_ok());
 //! # Ok(())
 //! # }
 //!
@@ -34,7 +34,8 @@
 //! # #[cfg(all(feature = "tokio1", feature = "sendmail-transport", feature = "builder"))]
 //! # async fn run() -> Result<(), Box<dyn Error>> {
 //! use lettre::{
-//!     AsyncSendmailTransport, AsyncTransport, Message, SendmailTransport, Tokio1Executor,
+//!     message::header::ContentType, AsyncSendmailTransport, AsyncTransport, Message,
+//!     SendmailTransport, Tokio1Executor,
 //! };
 //!
 //! let email = Message::builder()
@@ -42,11 +43,11 @@
 //!     .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!"))?;
 //!
 //! let sender = AsyncSendmailTransport::<Tokio1Executor>::new();
-//! let result = sender.send(email).await;
+//! sender.send(email).await?;
-//! assert!(result.is_ok());
 //! # Ok(())
 //! # }
 //! ```
@@ -58,18 +59,17 @@
 //! #
 //! # #[cfg(all(feature = "async-std1", feature = "sendmail-transport", feature = "builder"))]
 //! # async fn run() -> Result<(), Box<dyn Error>> {
-//! use lettre::{Message, AsyncTransport, AsyncStd1Executor, AsyncSendmailTransport};
+//! use lettre::{Message, AsyncTransport, AsyncStd1Executor,message::header::ContentType, AsyncSendmailTransport};
 //!
 //! let email = Message::builder()
 //!     .from("NoBody <nobody@domain.tld>".parse()?)
 //!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
 //!     .to("Hei <hei@domain.tld>".parse()?)
-//!     .subject("Happy new year")
+//!     .subject("Happy new year").header(ContentType::TEXT_PLAIN)
 //!     .body(String::from("Be happy!"))?;
 //!
 //! let sender = AsyncSendmailTransport::<AsyncStd1Executor>::new();
-//! let result = sender.send(email).await;
+//! sender.send(email).await?;
-//! assert!(result.is_ok());
 //! # Ok(())
 //! # }
 //! ```
@@ -120,7 +120,7 @@ impl SendmailTransport {
     /// 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].
+    /// use [`SendmailTransport::new_with_command`].
     pub fn new() -> SendmailTransport {
         SendmailTransport {
             command: DEFAULT_SENDMAIL.into(),
@@ -157,7 +157,7 @@ where
     /// 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].
+    /// use [`AsyncSendmailTransport::new_with_command`].
     pub fn new() -> Self {
         Self {
             inner: SendmailTransport::new(),

src/transport/smtp/async_transport.rs

@@ -12,6 +12,12 @@ use async_trait::async_trait;
 use super::pool::async_impl::Pool;
 #[cfg(feature = "pool")]
 use super::PoolConfig;
+#[cfg(any(
+    feature = "tokio1-native-tls",
+    feature = "tokio1-rustls-tls",
+    feature = "async-std1-rustls-tls"
+))]
+use super::Tls;
 use super::{
     client::AsyncSmtpConnection, ClientId, Credentials, Error, Mechanism, Response, SmtpInfo,
 };
@@ -24,6 +30,30 @@ use crate::Tokio1Executor;
 use crate::{Envelope, Executor};
 
 /// Asynchronously sends emails using the SMTP protocol
+///
+/// `AsyncSmtpTransport` is the primary way for communicating
+/// with SMTP relay servers to send email messages. It holds the
+/// client connect configuration and creates new connections
+/// as necessary.
+///
+/// # Connection pool
+///
+/// When the `pool` feature is enabled (default), `AsyncSmtpTransport` maintains a
+/// connection pool to manage SMTP connections. The pool:
+///
+/// - Establishes a new connection when sending a message.
+/// - Recycles connections internally after a message is sent.
+/// - Reuses connections for subsequent messages, reducing connection setup overhead.
+///
+/// The connection pool can grow to hold multiple SMTP connections if multiple
+/// emails are sent concurrently, as SMTP does not support multiplexing within a
+/// single connection.
+///
+/// However, **connection reuse is not possible** if the `SyncSmtpTransport` instance
+/// is dropped after every email send operation. You must reuse the instance
+/// of this struct for the connection pool to be of any use.
+///
+/// To customize connection pool settings, use [`AsyncSmtpTransportBuilder::pool_config`].
 #[cfg_attr(docsrs, doc(cfg(any(feature = "tokio1", feature = "async-std1"))))]
 pub struct AsyncSmtpTransport<E: Executor> {
     #[cfg(feature = "pool")]
@@ -45,7 +75,7 @@ impl AsyncTransport for AsyncSmtpTransport<Tokio1Executor> {
         let result = conn.send(envelope, email).await?;
 
         #[cfg(not(feature = "pool"))]
-        conn.quit().await?;
+        conn.abort().await;
 
         Ok(result)
     }
@@ -82,7 +112,6 @@ where
     #[cfg(any(
         feature = "tokio1-native-tls",
         feature = "tokio1-rustls-tls",
-        feature = "async-std1-native-tls",
         feature = "async-std1-rustls-tls"
     ))]
     #[cfg_attr(
@@ -117,7 +146,6 @@ where
     #[cfg(any(
         feature = "tokio1-native-tls",
         feature = "tokio1-rustls-tls",
-        feature = "async-std1-native-tls",
         feature = "async-std1-rustls-tls"
     ))]
     #[cfg_attr(
@@ -163,54 +191,72 @@ where
 
     /// Creates a `AsyncSmtpTransportBuilder` from a connection URL
     ///
-    /// The protocol, credentials, host and port can be provided in a single URL.
+    /// The protocol, credentials, host, port and EHLO name can be provided
-    /// Use the scheme `smtp` for an unencrypted relay (optionally in combination with the
+    /// in a single URL. This may be simpler than having to configure SMTP
-    /// `tls` parameter to allow/require STARTTLS) or `smtps` for SMTP over TLS.
+    /// through multiple configuration parameters and then having to pass
-    /// The path section of the url can be used to set an alternative name for
+    /// those options to lettre.
-    /// 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>
+    /// The URL is created in the following way:
-    ///   <thead>
+    /// `scheme://user:pass@hostname:port/ehlo-name?tls=TLS`.
-    ///     <tr>
+    ///
-    ///       <th>scheme</th>
+    /// `user` (Username) and `pass` (Password) are optional in case the
-    ///       <th>tls parameter</th>
+    /// SMTP relay doesn't require authentication. When `port` is not
-    ///       <th>example</th>
+    /// configured it is automatically determined based on the `scheme`.
-    ///       <th>remarks</th>
+    /// `ehlo-name` optionally overwrites the hostname sent for the EHLO
-    ///     </tr>
+    /// command. `TLS` controls whether STARTTLS is simply enabled
-    ///   </thead>
+    /// (`opportunistic` - not enough to prevent man-in-the-middle attacks)
-    ///   <tbody>
+    /// or `required` (require the server to upgrade the connection to
-    ///     <tr>
+    /// STARTTLS, otherwise fail on suspicion of main-in-the-middle attempt).
-    ///      <td>smtps</td>
+    ///
-    ///      <td>-</td>
+    /// Use the following table to construct your SMTP url:
-    ///      <td>smtps://smtp.example.com</td>
+    ///
-    ///      <td>SMTP over TLS, recommended method</td>
+    /// | scheme  | `tls` query parameter | example                                            | default port | remarks                                                                                                                               |
-    ///     </tr>
+    /// | ------- | --------------------- | -------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------------- |
-    ///     <tr>
+    /// | `smtps` | unset                 | `smtps://user:pass@hostname:port`                  | 465          | SMTP over TLS, recommended method                                                                                                     |
-    ///      <td>smtp</td>
+    /// | `smtp`  | `required`            | `smtp://user:pass@hostname:port?tls=required`      | 587          | SMTP with STARTTLS required, when SMTP over TLS is not available                                                                      |
-    ///      <td>required</td>
+    /// | `smtp`  | `opportunistic`       | `smtp://user:pass@hostname:port?tls=opportunistic` | 587          | SMTP with optionally STARTTLS when supported by the server. Not suitable for production use: vulnerable to a man-in-the-middle attack |
-    ///      <td>smtp://smtp.example.com?tls=required</td>
+    /// | `smtp`  | unset                 | `smtp://user:pass@hostname:port`                   | 587          | Always unencrypted SMTP. Not suitable for production use: sends all data unencrypted                                                  |
-    ///      <td>SMTP with STARTTLS required, when SMTP over TLS is not available</td>
+    ///
-    ///     </tr>
+    /// IMPORTANT: some parameters like `user` and `pass` cannot simply
-    ///     <tr>
+    /// be concatenated to construct the final URL because special characters
-    ///      <td>smtp</td>
+    /// contained within the parameter may confuse the URL decoder.
-    ///      <td>opportunistic</td>
+    /// Manually URL encode the parameters before concatenating them or use
-    ///      <td>smtp://smtp.example.com?tls=opportunistic</td>
+    /// a proper URL encoder, like the following cargo script:
-    ///      <td>
+    ///
-    ///         SMTP with optionally STARTTLS when supported by the server.
+    /// ```rust
-    ///         Caution: this method is vulnerable to a man-in-the-middle attack.
+    /// # let _ = r#"
-    ///         Not recommended for production use.
+    /// #!/usr/bin/env cargo
-    ///       </td>
+    ///
-    ///     </tr>
+    /// //! ```cargo
-    ///     <tr>
+    /// //! [dependencies]
-    ///      <td>smtp</td>
+    /// //! url = "2"
-    ///      <td>-</td>
+    /// //! ```
-    ///      <td>smtp://smtp.example.com</td>
+    /// # "#;
-    ///      <td>Unencrypted SMTP, not recommended for production use.</td>
+    ///
-    ///     </tr>
+    /// use url::Url;
-    ///   </tbody>
+    ///
-    /// </table>
+    /// fn main() {
+    ///     // don't touch this line
+    ///     let mut url = Url::parse("foo://bar").unwrap();
+    ///
+    ///     // configure the scheme (`smtp` or `smtps`) here.
+    ///     url.set_scheme("smtps").unwrap();
+    ///     // configure the username and password.
+    ///     // remove the following two lines if unauthenticated.
+    ///     url.set_username("username").unwrap();
+    ///     url.set_password(Some("password")).unwrap();
+    ///     // configure the hostname
+    ///     url.set_host(Some("smtp.example.com")).unwrap();
+    ///     // configure the port - only necessary if using a non-default port
+    ///     url.set_port(Some(465)).unwrap();
+    ///     // configure the EHLO name
+    ///     url.set_path("ehlo-name");
+    ///
+    ///     println!("{url}");
+    /// }
+    /// ```
+    ///
+    /// The connection URL can then be used in the following way:
     ///
     /// ```rust,no_run
     /// use lettre::{
@@ -234,15 +280,11 @@ where
     /// 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 {
+    /// mailer.send(email).await?;
-    ///     Ok(_) => println!("Email sent successfully!"),
-    ///     Err(e) => panic!("Could not send email: {e:?}"),
-    /// }
     /// # Ok(())
     /// # }
     /// ```
@@ -325,7 +367,7 @@ impl AsyncSmtpTransportBuilder {
         self
     }
 
-    /// Set the authentication mechanism to use
+    /// Set the authentication credentials to use
     pub fn credentials(mut self, credentials: Credentials) -> Self {
         self.info.credentials = Some(credentials);
         self
@@ -338,6 +380,17 @@ impl AsyncSmtpTransportBuilder {
     }
 
     /// Set the port to use
+    ///
+    /// # ⚠️⚠️⚠️ You probably don't need to call this method ⚠️⚠️⚠️
+    ///
+    /// lettre usually picks the correct `port` when building
+    /// [`AsyncSmtpTransport`] using [`AsyncSmtpTransport::relay`] or
+    /// [`AsyncSmtpTransport::starttls_relay`].
+    ///
+    /// # Errors
+    ///
+    /// Using the incorrect `port` and [`Self::tls`] combination may
+    /// lead to hard to debug IO errors coming from the TLS library.
     pub fn port(mut self, port: u16) -> Self {
         self.info.port = port;
         self
@@ -350,10 +403,20 @@ impl AsyncSmtpTransportBuilder {
     }
 
     /// Set the TLS settings to use
+    ///
+    /// # ⚠️⚠️⚠️ You probably don't need to call this method ⚠️⚠️⚠️
+    ///
+    /// By default lettre chooses the correct `tls` configuration when
+    /// building [`AsyncSmtpTransport`] using [`AsyncSmtpTransport::relay`] or
+    /// [`AsyncSmtpTransport::starttls_relay`].
+    ///
+    /// # Errors
+    ///
+    /// Using the incorrect [`Tls`] and [`Self::port`] combination may
+    /// lead to hard to debug IO errors coming from the TLS library.
     #[cfg(any(
         feature = "tokio1-native-tls",
         feature = "tokio1-rustls-tls",
-        feature = "async-std1-native-tls",
         feature = "async-std1-rustls-tls"
     ))]
     #[cfg_attr(
@@ -364,7 +427,7 @@ impl AsyncSmtpTransportBuilder {
             feature = "async-std1-rustls-tls"
         )))
     )]
-    pub fn tls(mut self, tls: super::Tls) -> Self {
+    pub fn tls(mut self, tls: Tls) -> Self {
         self.info.tls = tls;
         self
     }

src/transport/smtp/authentication.rs

@@ -98,11 +98,17 @@ impl Mechanism {
                 let decoded_challenge = challenge
                     .ok_or_else(|| error::client("This mechanism does expect a challenge"))?;
 
-                if ["User Name", "Username:", "Username"].contains(&decoded_challenge) {
+                if contains_ignore_ascii_case(
+                    decoded_challenge,
+                    ["User Name", "Username:", "Username", "User Name\0"],
+                ) {
                     return Ok(credentials.authentication_identity.clone());
                 }
 
-                if ["Password", "Password:"].contains(&decoded_challenge) {
+                if contains_ignore_ascii_case(
+                    decoded_challenge,
+                    ["Password", "Password:", "Password\0"],
+                ) {
                     return Ok(credentials.secret.clone());
                 }
 
@@ -119,6 +125,15 @@ impl Mechanism {
     }
 }
 
+fn contains_ignore_ascii_case<'a>(
+    haystack: &str,
+    needles: impl IntoIterator<Item = &'a str>,
+) -> bool {
+    needles
+        .into_iter()
+        .any(|item| item.eq_ignore_ascii_case(haystack))
+}
+
 #[cfg(test)]
 mod test {
     use super::{Credentials, Mechanism};
@@ -153,6 +168,23 @@ mod test {
         assert!(mechanism.response(&credentials, None).is_err());
     }
 
+    #[test]
+    fn test_login_case_insensitive() {
+        let mechanism = Mechanism::Login;
+
+        let credentials = Credentials::new("alice".to_owned(), "wonderland".to_owned());
+
+        assert_eq!(
+            mechanism.response(&credentials, Some("username")).unwrap(),
+            "alice"
+        );
+        assert_eq!(
+            mechanism.response(&credentials, Some("password")).unwrap(),
+            "wonderland"
+        );
+        assert!(mechanism.response(&credentials, None).is_err());
+    }
+
     #[test]
     fn test_xoauth2() {
         let mechanism = Mechanism::Xoauth2;

src/transport/smtp/client/async_connection.rs

@@ -65,7 +65,7 @@ impl AsyncSmtpConnection {
     /// If `tls_parameters` is `Some`, then the connection will use Implicit TLS (sometimes
     /// referred to as `SMTPS`). See also [`AsyncSmtpConnection::starttls`].
     ///
-    /// If `local_addres` is `Some`, then the address provided shall be used to bind the
+    /// 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
@@ -86,8 +86,7 @@ impl AsyncSmtpConnection {
     ///     Some(TlsParameters::new("example.com".to_owned())?),
     ///     None,
     /// )
-    /// .await
+    /// .await?;
-    /// .unwrap();
     /// # Ok(())
     /// # }
     /// ```
@@ -373,4 +372,26 @@ impl AsyncSmtpConnection {
     pub fn peer_certificate(&self) -> Result<Vec<u8>, Error> {
         self.stream.get_ref().peer_certificate()
     }
+
+    /// Currently this is only avaialable when using Boring TLS and
+    /// returns the result of the verification of the TLS certificate
+    /// presented by the peer, if any. Only the last error encountered
+    /// during verification is presented.
+    /// It can be useful when you don't want to fail outright the TLS
+    /// negotiation, for example when a self-signed certificate is
+    /// encountered, but still want to record metrics or log the fact.
+    /// When using DANE verification, the PKI root of trust moves from
+    /// the CAs to DNS, so self-signed certificates are permitted as long
+    /// as the TLSA records match the leaf or issuer certificates.
+    /// It cannot be called on non Boring TLS streams.
+    #[cfg(feature = "boring-tls")]
+    pub fn tls_verify_result(&self) -> Result<(), Error> {
+        self.stream.get_ref().tls_verify_result()
+    }
+
+    /// 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

@@ -6,8 +6,6 @@ use std::{
     time::Duration,
 };
 
-#[cfg(feature = "async-std1-native-tls")]
-use async_native_tls::TlsStream as AsyncStd1TlsStream;
 #[cfg(feature = "async-std1")]
 use async_std::net::{TcpStream as AsyncStd1TcpStream, ToSocketAddrs as AsyncStd1ToSocketAddrs};
 use futures_io::{
@@ -16,6 +14,8 @@ use futures_io::{
 };
 #[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")]
@@ -34,7 +34,6 @@ use tokio1_rustls::client::TlsStream as Tokio1RustlsTlsStream;
     feature = "tokio1-native-tls",
     feature = "tokio1-rustls-tls",
     feature = "tokio1-boring-tls",
-    feature = "async-std1-native-tls",
     feature = "async-std1-rustls-tls"
 ))]
 use super::InnerTlsParameters;
@@ -84,9 +83,6 @@ enum InnerAsyncNetworkStream {
     #[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
@@ -104,23 +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(ref s) => s.get_ref().peer_addr(),
+            InnerAsyncNetworkStream::Tokio1BoringTls(s) => s.get_ref().peer_addr(),
             #[cfg(feature = "async-std1")]
-            InnerAsyncNetworkStream::AsyncStd1Tcp(ref s) => s.peer_addr(),
+            InnerAsyncNetworkStream::AsyncStd1Tcp(s) => s.peer_addr(),
-            #[cfg(feature = "async-std1-native-tls")]
-            InnerAsyncNetworkStream::AsyncStd1NativeTls(ref s) => s.get_ref().peer_addr(),
             #[cfg(feature = "async-std1-rustls-tls")]
-            InnerAsyncNetworkStream::AsyncStd1RustlsTls(ref s) => s.get_ref().0.peer_addr(),
+            InnerAsyncNetworkStream::AsyncStd1RustlsTls(s) => s.get_ref().0.peer_addr(),
             InnerAsyncNetworkStream::None => {
                 debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
                 Err(IoError::new(
@@ -176,7 +170,7 @@ impl AsyncNetworkStream {
                             last_err = Some(io::Error::new(
                                 io::ErrorKind::TimedOut,
                                 "connection timed out",
-                            ))
+                            ));
                         }
                     }
                 } else {
@@ -228,7 +222,7 @@ impl AsyncNetworkStream {
                         last_err = Some(io::Error::new(
                             io::ErrorKind::TimedOut,
                             "connection timed out",
-                        ))
+                        ));
                     }
                 }
             }
@@ -276,9 +270,8 @@ impl AsyncNetworkStream {
             InnerAsyncNetworkStream::Tokio1Tcp(_) => {
                 // get owned TcpStream
                 let tcp_stream = mem::replace(&mut self.inner, InnerAsyncNetworkStream::None);
-                let tcp_stream = match tcp_stream {
+                let InnerAsyncNetworkStream::Tokio1Tcp(tcp_stream) = tcp_stream else {
-                    InnerAsyncNetworkStream::Tokio1Tcp(tcp_stream) => tcp_stream,
+                    unreachable!()
-                    _ => unreachable!(),
                 };
 
                 self.inner = Self::upgrade_tokio1_tls(tcp_stream, tls_parameters)
@@ -286,22 +279,18 @@ impl AsyncNetworkStream {
                     .map_err(error::connection)?;
                 Ok(())
             }
-            #[cfg(all(
+            #[cfg(all(feature = "async-std1", not(feature = "async-std1-rustls-tls")))]
-                feature = "async-std1",
-                not(any(feature = "async-std1-native-tls", feature = "async-std1-rustls-tls"))
-            ))]
             InnerAsyncNetworkStream::AsyncStd1Tcp(_) => {
                 let _ = tls_parameters;
-                panic!("Trying to upgrade an AsyncNetworkStream without having enabled either the async-std1-native-tls or the async-std1-rustls-tls feature");
+                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);
-                let tcp_stream = match tcp_stream {
+                let InnerAsyncNetworkStream::AsyncStd1Tcp(tcp_stream) = tcp_stream else {
-                    InnerAsyncNetworkStream::AsyncStd1Tcp(tcp_stream) => tcp_stream,
+                    unreachable!()
-                    _ => unreachable!(),
                 };
 
                 self.inner = Self::upgrade_asyncstd1_tls(tcp_stream, tls_parameters)
@@ -350,7 +339,6 @@ impl AsyncNetworkStream {
 
                 #[cfg(feature = "tokio1-rustls-tls")]
                 return {
-                    use rustls::ServerName;
                     use tokio1_rustls::TlsConnector;
 
                     let domain = ServerName::try_from(domain.as_str())
@@ -358,7 +346,7 @@ impl AsyncNetworkStream {
 
                     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))
@@ -384,11 +372,7 @@ impl AsyncNetworkStream {
     }
 
     #[allow(unused_variables)]
-    #[cfg(any(
+    #[cfg(feature = "async-std1-rustls-tls")]
-        feature = "async-std1-native-tls",
-        feature = "async-std1-rustls-tls",
-        feature = "async-std1-boring-tls"
-    ))]
     async fn upgrade_asyncstd1_tls(
         tcp_stream: AsyncStd1TcpStream,
         mut tls_parameters: TlsParameters,
@@ -399,22 +383,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) => {
@@ -424,14 +392,13 @@ impl AsyncNetworkStream {
                 #[cfg(feature = "async-std1-rustls-tls")]
                 return {
                     use futures_rustls::TlsConnector;
-                    use rustls::ServerName;
 
                     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))
@@ -445,7 +412,7 @@ impl AsyncNetworkStream {
     }
 
     pub fn is_encrypted(&self) -> bool {
-        match self.inner {
+        match &self.inner {
             #[cfg(feature = "tokio1")]
             InnerAsyncNetworkStream::Tokio1Tcp(_) => false,
             #[cfg(feature = "tokio1-native-tls")]
@@ -456,14 +423,78 @@ impl AsyncNetworkStream {
             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,
         }
     }
 
+    #[cfg(feature = "boring-tls")]
+    pub fn tls_verify_result(&self) -> Result<(), 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(_) => panic!("Unsupported"),
+            #[cfg(feature = "tokio1-boring-tls")]
+            InnerAsyncNetworkStream::Tokio1BoringTls(stream) => {
+                stream.ssl().verify_result().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(_) => panic!("Unsupported"),
+            InnerAsyncNetworkStream::None => panic!("InnerNetworkStream::None must never be built"),
+        }
+    }
+    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")]
@@ -486,8 +517,7 @@ impl AsyncNetworkStream {
                 .unwrap()
                 .first()
                 .unwrap()
-                .clone()
+                .to_vec()),
-                .0),
             #[cfg(feature = "tokio1-boring-tls")]
             InnerAsyncNetworkStream::Tokio1BoringTls(stream) => Ok(stream
                 .ssl()
@@ -499,8 +529,6 @@ impl AsyncNetworkStream {
             InnerAsyncNetworkStream::AsyncStd1Tcp(_) => {
                 Err(error::client("Connection is not encrypted"))
             }
-            #[cfg(feature = "async-std1-native-tls")]
-            InnerAsyncNetworkStream::AsyncStd1NativeTls(t) => panic!("Unsupported"),
             #[cfg(feature = "async-std1-rustls-tls")]
             InnerAsyncNetworkStream::AsyncStd1RustlsTls(stream) => Ok(stream
                 .get_ref()
@@ -509,8 +537,7 @@ impl AsyncNetworkStream {
                 .unwrap()
                 .first()
                 .unwrap()
-                .clone()
+                .to_vec()),
-                .0),
             InnerAsyncNetworkStream::None => panic!("InnerNetworkStream::None must never be built"),
         }
     }
@@ -522,9 +549,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())),
@@ -533,7 +560,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())),
@@ -542,7 +569,7 @@ 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())),
@@ -551,7 +578,7 @@ impl FuturesAsyncRead for AsyncNetworkStream {
                 }
             }
             #[cfg(feature = "tokio1-boring-tls")]
-            InnerAsyncNetworkStream::Tokio1BoringTls(ref mut s) => {
+            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())),
@@ -560,15 +587,9 @@ impl FuturesAsyncRead for AsyncNetworkStream {
                 }
             }
             #[cfg(feature = "async-std1")]
-            InnerAsyncNetworkStream::AsyncStd1Tcp(ref mut s) => Pin::new(s).poll_read(cx, buf),
+            InnerAsyncNetworkStream::AsyncStd1Tcp(s) => Pin::new(s).poll_read(cx, buf),
-            #[cfg(feature = "async-std1-native-tls")]
-            InnerAsyncNetworkStream::AsyncStd1NativeTls(ref mut s) => {
-                Pin::new(s).poll_read(cx, buf)
-            }
             #[cfg(feature = "async-std1-rustls-tls")]
-            InnerAsyncNetworkStream::AsyncStd1RustlsTls(ref mut s) => {
+            InnerAsyncNetworkStream::AsyncStd1RustlsTls(s) => Pin::new(s).poll_read(cx, buf),
-                Pin::new(s).poll_read(cx, buf)
-            }
             InnerAsyncNetworkStream::None => {
                 debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
                 Poll::Ready(Ok(0))
@@ -583,25 +604,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(ref mut s) => Pin::new(s).poll_write(cx, buf),
+            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),
+            InnerAsyncNetworkStream::AsyncStd1Tcp(s) => Pin::new(s).poll_write(cx, buf),
-            #[cfg(feature = "async-std1-native-tls")]
-            InnerAsyncNetworkStream::AsyncStd1NativeTls(ref mut s) => {
-                Pin::new(s).poll_write(cx, buf)
-            }
             #[cfg(feature = "async-std1-rustls-tls")]
-            InnerAsyncNetworkStream::AsyncStd1RustlsTls(ref mut s) => {
+            InnerAsyncNetworkStream::AsyncStd1RustlsTls(s) => Pin::new(s).poll_write(cx, buf),
-                Pin::new(s).poll_write(cx, buf)
-            }
             InnerAsyncNetworkStream::None => {
                 debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
                 Poll::Ready(Ok(0))
@@ -610,21 +625,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(ref mut s) => Pin::new(s).poll_flush(cx),
+            InnerAsyncNetworkStream::Tokio1BoringTls(s) => Pin::new(s).poll_flush(cx),
             #[cfg(feature = "async-std1")]
-            InnerAsyncNetworkStream::AsyncStd1Tcp(ref mut s) => Pin::new(s).poll_flush(cx),
+            InnerAsyncNetworkStream::AsyncStd1Tcp(s) => Pin::new(s).poll_flush(cx),
-            #[cfg(feature = "async-std1-native-tls")]
-            InnerAsyncNetworkStream::AsyncStd1NativeTls(ref mut s) => Pin::new(s).poll_flush(cx),
             #[cfg(feature = "async-std1-rustls-tls")]
-            InnerAsyncNetworkStream::AsyncStd1RustlsTls(ref mut s) => Pin::new(s).poll_flush(cx),
+            InnerAsyncNetworkStream::AsyncStd1RustlsTls(s) => Pin::new(s).poll_flush(cx),
             InnerAsyncNetworkStream::None => {
                 debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
                 Poll::Ready(Ok(()))
@@ -633,21 +646,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(ref mut s) => Pin::new(s).poll_shutdown(cx),
+            InnerAsyncNetworkStream::Tokio1BoringTls(s) => Pin::new(s).poll_shutdown(cx),
             #[cfg(feature = "async-std1")]
-            InnerAsyncNetworkStream::AsyncStd1Tcp(ref mut s) => Pin::new(s).poll_close(cx),
+            InnerAsyncNetworkStream::AsyncStd1Tcp(s) => Pin::new(s).poll_close(cx),
-            #[cfg(feature = "async-std1-native-tls")]
-            InnerAsyncNetworkStream::AsyncStd1NativeTls(ref mut s) => Pin::new(s).poll_close(cx),
             #[cfg(feature = "async-std1-rustls-tls")]
-            InnerAsyncNetworkStream::AsyncStd1RustlsTls(ref mut s) => Pin::new(s).poll_close(cx),
+            InnerAsyncNetworkStream::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

@@ -307,4 +307,26 @@ impl SmtpConnection {
     pub fn peer_certificate(&self) -> Result<Vec<u8>, Error> {
         self.stream.get_ref().peer_certificate()
     }
+
+    /// Currently this is only avaialable when using Boring TLS and
+    /// returns the result of the verification of the TLS certificate
+    /// presented by the peer, if any. Only the last error encountered
+    /// during verification is presented.
+    /// It can be useful when you don't want to fail outright the TLS
+    /// negotiation, for example when a self-signed certificate is
+    /// encountered, but still want to record metrics or log the fact.
+    /// When using DANE verification, the PKI root of trust moves from
+    /// the CAs to DNS, so self-signed certificates are permitted as long
+    /// as the TLSA records match the leaf or issuer certificates.
+    /// It cannot be called on non Boring TLS streams.
+    #[cfg(feature = "boring-tls")]
+    pub fn tls_verify_result(&self) -> Result<(), Error> {
+        self.stream.get_ref().tls_verify_result()
+    }
+
+    /// 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

@@ -38,7 +38,7 @@ pub(super) use self::tls::InnerTlsParameters;
 pub use self::tls::TlsVersion;
 pub use self::{
     connection::SmtpConnection,
-    tls::{Certificate, CertificateStore, Tls, TlsParameters, TlsParametersBuilder},
+    tls::{Certificate, CertificateStore, Identity, Tls, TlsParameters, TlsParametersBuilder},
 };
 
 #[cfg(any(feature = "tokio1", feature = "async-std1"))]
@@ -139,7 +139,7 @@ mod test {
     }
 
     #[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

@@ -12,7 +12,7 @@ use boring::ssl::SslStream;
 #[cfg(feature = "native-tls")]
 use native_tls::TlsStream;
 #[cfg(feature = "rustls-tls")]
-use rustls::{ClientConnection, ServerName, StreamOwned};
+use rustls::{pki_types::ServerName, ClientConnection, StreamOwned};
 use socket2::{Domain, Protocol, Type};
 
 #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
@@ -55,14 +55,14 @@ impl NetworkStream {
 
     /// Returns peer's address
     pub fn peer_addr(&self) -> io::Result<SocketAddr> {
-        match self.inner {
+        match &self.inner {
-            InnerNetworkStream::Tcp(ref s) => s.peer_addr(),
+            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(ref s) => s.get_ref().peer_addr(),
+            InnerNetworkStream::BoringTls(s) => s.get_ref().peer_addr(),
             InnerNetworkStream::None => {
                 debug_assert!(false, "InnerNetworkStream::None must never be built");
                 Ok(SocketAddr::V4(SocketAddrV4::new(
@@ -75,14 +75,14 @@ impl NetworkStream {
 
     /// Shutdowns the connection
     pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
-        match self.inner {
+        match &self.inner {
-            InnerNetworkStream::Tcp(ref s) => s.shutdown(how),
+            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(ref s) => s.get_ref().shutdown(how),
+            InnerNetworkStream::BoringTls(s) => s.get_ref().shutdown(how),
             InnerNetworkStream::None => {
                 debug_assert!(false, "InnerNetworkStream::None must never be built");
                 Ok(())
@@ -119,12 +119,12 @@ impl NetworkStream {
 
                 if let Some(timeout) = timeout {
                     match socket.connect_timeout(&addr.into(), timeout) {
-                        Ok(_) => return Ok(socket.into()),
+                        Ok(()) => return Ok(socket.into()),
                         Err(err) => last_err = Some(err),
                     }
                 } else {
                     match socket.connect(&addr.into()) {
-                        Ok(_) => return Ok(socket.into()),
+                        Ok(()) => return Ok(socket.into()),
                         Err(err) => last_err = Some(err),
                     }
                 }
@@ -160,9 +160,8 @@ impl NetworkStream {
             InnerNetworkStream::Tcp(_) => {
                 // get owned TcpStream
                 let tcp_stream = mem::replace(&mut self.inner, InnerNetworkStream::None);
-                let tcp_stream = match tcp_stream {
+                let InnerNetworkStream::Tcp(tcp_stream) = tcp_stream else {
-                    InnerNetworkStream::Tcp(tcp_stream) => tcp_stream,
+                    unreachable!()
-                    _ => unreachable!(),
                 };
 
                 self.inner = Self::upgrade_tls_impl(tcp_stream, tls_parameters)?;
@@ -189,7 +188,7 @@ impl NetworkStream {
             InnerTlsParameters::RustlsTls(connector) => {
                 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)
+                let connection = ClientConnection::new(Arc::clone(connector), domain.to_owned())
                     .map_err(error::connection)?;
                 let stream = StreamOwned::new(connection, tcp_stream);
                 InnerNetworkStream::RustlsTls(stream)
@@ -208,7 +207,7 @@ impl NetworkStream {
     }
 
     pub fn is_encrypted(&self) -> bool {
-        match self.inner {
+        match &self.inner {
             InnerNetworkStream::Tcp(_) => false,
             #[cfg(feature = "native-tls")]
             InnerNetworkStream::NativeTls(_) => true,
@@ -223,6 +222,48 @@ impl NetworkStream {
         }
     }
 
+    #[cfg(feature = "boring-tls")]
+    pub fn tls_verify_result(&self) -> Result<(), Error> {
+        match &self.inner {
+            InnerNetworkStream::Tcp(_) => Err(error::client("Connection is not encrypted")),
+            #[cfg(feature = "native-tls")]
+            InnerNetworkStream::NativeTls(_) => panic!("Unsupported"),
+            #[cfg(feature = "rustls-tls")]
+            InnerNetworkStream::RustlsTls(_) => panic!("Unsupported"),
+            #[cfg(feature = "boring-tls")]
+            InnerNetworkStream::BoringTls(stream) => {
+                stream.ssl().verify_result().map_err(error::tls)
+            }
+            InnerNetworkStream::None => panic!("InnerNetworkStream::None must never be built"),
+        }
+    }
+
+    #[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(_) => panic!("Unsupported"),
+            #[cfg(feature = "rustls-tls")]
+            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 {
@@ -241,8 +282,7 @@ impl NetworkStream {
                 .unwrap()
                 .first()
                 .unwrap()
-                .clone()
+                .to_vec()),
-                .0),
             #[cfg(feature = "boring-tls")]
             InnerNetworkStream::BoringTls(stream) => Ok(stream
                 .ssl()
@@ -255,20 +295,14 @@ impl NetworkStream {
     }
 
     pub fn set_read_timeout(&mut self, duration: Option<Duration>) -> io::Result<()> {
-        match self.inner {
+        match &mut self.inner {
-            InnerNetworkStream::Tcp(ref mut stream) => stream.set_read_timeout(duration),
+            InnerNetworkStream::Tcp(stream) => stream.set_read_timeout(duration),
             #[cfg(feature = "native-tls")]
-            InnerNetworkStream::NativeTls(ref mut stream) => {
+            InnerNetworkStream::NativeTls(stream) => stream.get_ref().set_read_timeout(duration),
-                stream.get_ref().set_read_timeout(duration)
-            }
             #[cfg(feature = "rustls-tls")]
-            InnerNetworkStream::RustlsTls(ref mut stream) => {
+            InnerNetworkStream::RustlsTls(stream) => stream.get_ref().set_read_timeout(duration),
-                stream.get_ref().set_read_timeout(duration)
-            }
             #[cfg(feature = "boring-tls")]
-            InnerNetworkStream::BoringTls(ref mut stream) => {
+            InnerNetworkStream::BoringTls(stream) => stream.get_ref().set_read_timeout(duration),
-                stream.get_ref().set_read_timeout(duration)
-            }
             InnerNetworkStream::None => {
                 debug_assert!(false, "InnerNetworkStream::None must never be built");
                 Ok(())
@@ -278,21 +312,15 @@ impl NetworkStream {
 
     /// Set write timeout for IO calls
     pub fn set_write_timeout(&mut self, duration: Option<Duration>) -> io::Result<()> {
-        match self.inner {
+        match &mut self.inner {
-            InnerNetworkStream::Tcp(ref mut stream) => stream.set_write_timeout(duration),
+            InnerNetworkStream::Tcp(stream) => stream.set_write_timeout(duration),
 
             #[cfg(feature = "native-tls")]
-            InnerNetworkStream::NativeTls(ref mut stream) => {
+            InnerNetworkStream::NativeTls(stream) => stream.get_ref().set_write_timeout(duration),
-                stream.get_ref().set_write_timeout(duration)
-            }
             #[cfg(feature = "rustls-tls")]
-            InnerNetworkStream::RustlsTls(ref mut stream) => {
+            InnerNetworkStream::RustlsTls(stream) => stream.get_ref().set_write_timeout(duration),
-                stream.get_ref().set_write_timeout(duration)
-            }
             #[cfg(feature = "boring-tls")]
-            InnerNetworkStream::BoringTls(ref mut stream) => {
+            InnerNetworkStream::BoringTls(stream) => stream.get_ref().set_write_timeout(duration),
-                stream.get_ref().set_write_timeout(duration)
-            }
             InnerNetworkStream::None => {
                 debug_assert!(false, "InnerNetworkStream::None must never be built");
                 Ok(())
@@ -303,14 +331,14 @@ impl NetworkStream {
 
 impl Read for NetworkStream {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        match self.inner {
+        match &mut self.inner {
-            InnerNetworkStream::Tcp(ref mut s) => s.read(buf),
+            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(ref mut s) => s.read(buf),
+            InnerNetworkStream::BoringTls(s) => s.read(buf),
             InnerNetworkStream::None => {
                 debug_assert!(false, "InnerNetworkStream::None must never be built");
                 Ok(0)
@@ -321,14 +349,14 @@ impl Read for NetworkStream {
 
 impl Write for NetworkStream {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        match self.inner {
+        match &mut self.inner {
-            InnerNetworkStream::Tcp(ref mut s) => s.write(buf),
+            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(ref mut s) => s.write(buf),
+            InnerNetworkStream::BoringTls(s) => s.write(buf),
             InnerNetworkStream::None => {
                 debug_assert!(false, "InnerNetworkStream::None must never be built");
                 Ok(0)
@@ -337,14 +365,14 @@ impl Write for NetworkStream {
     }
 
     fn flush(&mut self) -> io::Result<()> {
-        match self.inner {
+        match &mut self.inner {
-            InnerNetworkStream::Tcp(ref mut s) => s.flush(),
+            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(ref mut s) => s.flush(),
+            InnerNetworkStream::BoringTls(s) => s.flush(),
             InnerNetworkStream::None => {
                 debug_assert!(false, "InnerNetworkStream::None must never be built");
                 Ok(())
@@ -356,7 +384,7 @@ 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
+/// See: <https://github.com/hyperium/hyper/blob/faf24c6ad8eee1c3d5ccc9a4d4835717b8e2903f/src/client/connect/http.rs#L560>
 fn bind_local_address(
     socket: &socket2::Socket,
     dst_addr: &SocketAddr,

src/transport/smtp/client/tls.rs

@@ -1,9 +1,10 @@
 use std::fmt::{self, Debug};
 #[cfg(feature = "rustls-tls")]
-use std::{sync::Arc, time::SystemTime};
+use std::{io, sync::Arc};
 
 #[cfg(feature = "boring-tls")]
 use boring::{
+    pkey::PKey,
     ssl::{SslConnector, SslVersion},
     x509::store::X509StoreBuilder,
 };
@@ -11,8 +12,12 @@ use boring::{
 use native_tls::{Protocol, TlsConnector};
 #[cfg(feature = "rustls-tls")]
 use rustls::{
-    client::{ServerCertVerified, ServerCertVerifier, WebPkiVerifier},
+    client::danger::{HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier},
-    ClientConfig, Error as TlsError, RootCertStore, ServerName,
+    crypto::WebPkiSupportedAlgorithms,
+    crypto::{verify_tls12_signature, verify_tls13_signature},
+    pki_types::{CertificateDer, PrivateKeyDer, ServerName, UnixTime},
+    server::ParsedCertificate,
+    ClientConfig, DigitallySignedStruct, Error as TlsError, RootCertStore, SignatureScheme,
 };
 
 #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
@@ -54,27 +59,61 @@ pub enum TlsVersion {
     Tlsv13,
 }
 
-/// How to apply TLS to a client connection
+/// Specifies how to establish a TLS connection
+///
+/// TLDR: Use [`Tls::Wrapper`] or [`Tls::Required`] when
+/// connecting to a remote server, [`Tls::None`] when
+/// connecting to a local server.
 #[derive(Clone)]
 #[allow(missing_copy_implementations)]
 pub enum Tls {
-    /// Insecure connection only (for testing purposes)
+    /// Insecure (plaintext) connection only.
+    ///
+    /// This option **always** uses a plaintext connection and should only
+    /// be used for trusted local relays. It is **highly discouraged**
+    /// for remote servers, as it exposes credentials and emails to potential
+    /// interception.
+    ///
+    /// Note: Servers requiring credentials or emails to be sent over TLS
+    /// may reject connections when this option is used.
     None,
-    /// Start with insecure connection and use `STARTTLS` when available
+    /// Begin with a plaintext connection and attempt to use `STARTTLS` if available.
+    ///
+    /// lettre will try to upgrade to a TLS-secured connection but will fall back
+    /// to plaintext if the server does not support TLS. This option is provided for
+    /// compatibility but is **strongly discouraged**, as it exposes connections to
+    /// potential MITM (man-in-the-middle) attacks.
+    ///
+    /// Warning: A malicious intermediary could intercept the `STARTTLS` flag,
+    /// causing lettre to believe the server only supports plaintext connections.
     #[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`
+    /// Begin with a plaintext connection and require `STARTTLS` for security.
+    ///
+    /// lettre will upgrade plaintext TCP connections to TLS before transmitting
+    /// any sensitive data. If the server does not support TLS, the connection
+    /// attempt will fail, ensuring no credentials or emails are sent in plaintext.
+    ///
+    /// Unlike [`Tls::Opportunistic`], this option is secure against MITM attacks.
+    /// For optimal security and performance, consider using [`Tls::Wrapper`] instead,
+    /// as it requires fewer roundtrips to establish a secure connection.
     #[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
+    /// Establish a connection wrapped in TLS from the start.
+    ///
+    /// lettre connects to the server and immediately performs a TLS handshake.
+    /// If the handshake fails, the connection attempt is aborted without
+    /// transmitting any sensitive data.
+    ///
+    /// This is the fastest and most secure option for establishing a connection.
     #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
     #[cfg_attr(
         docsrs,
@@ -106,7 +145,7 @@ pub enum CertificateStore {
     /// 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 the system store if the `rustls-native-certs` feature is
+    /// 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.
@@ -115,7 +154,7 @@ pub enum CertificateStore {
     /// Use a hardcoded set of Mozilla roots via the `webpki-roots` crate.
     ///
     /// This option is only available in the rustls backend.
-    #[cfg(feature = "webpki-roots")]
+    #[cfg(feature = "rustls-tls")]
     WebpkiRoots,
     /// Don't use any system certificates.
     None,
@@ -137,6 +176,7 @@ 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"))]
@@ -150,6 +190,7 @@ impl TlsParametersBuilder {
             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"))]
@@ -165,12 +206,20 @@ impl TlsParametersBuilder {
 
     /// 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`.
@@ -182,10 +231,11 @@ impl TlsParametersBuilder {
     /// including those from other sites, are trusted.
     ///
     /// This method introduces significant vulnerabilities to man-in-the-middle attacks.
-    ///
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
-    /// Hostname verification can only be disabled with the `native-tls` TLS backend.
+    #[cfg_attr(
-    #[cfg(any(feature = "native-tls", feature = "boring-tls"))]
+        docsrs,
-    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "boring-tls"))))]
+        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
@@ -273,6 +323,10 @@ impl TlsParametersBuilder {
         };
 
         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),
@@ -315,6 +369,15 @@ impl TlsParametersBuilder {
             }
         }
 
+        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,
@@ -337,8 +400,6 @@ impl TlsParametersBuilder {
     #[cfg(feature = "rustls-tls")]
     #[cfg_attr(docsrs, doc(cfg(feature = "rustls-tls")))]
     pub fn build_rustls(self) -> Result<TlsParameters, Error> {
-        let tls = ClientConfig::builder();
-
         let just_version3 = &[&rustls::version::TLS13];
         let supported_versions = match self.min_tls_version {
             TlsVersion::Tlsv10 => {
@@ -351,75 +412,73 @@ impl TlsParametersBuilder {
             TlsVersion::Tlsv13 => just_version3,
         };
 
-        let tls = tls
+        let tls = ClientConfig::builder_with_protocol_versions(supported_versions);
-            .with_safe_default_cipher_suites()
+        let provider = rustls::crypto::CryptoProvider::get_default()
-            .with_safe_default_kx_groups()
+            .cloned()
-            .with_protocol_versions(supported_versions)
+            .unwrap_or_else(|| Arc::new(rustls::crypto::ring::default_provider()));
-            .map_err(error::tls)?;
 
-        let tls = if self.accept_invalid_certs {
+        // Build TLS config
-            tls.with_custom_certificate_verifier(Arc::new(InvalidCertsVerifier {}))
+        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) {
+            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"
+            );
+        }
+
+        #[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 {
+                root_cert_store.add(rustls_cert).map_err(error::tls)?;
+            }
+        }
+
+        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 {
-            let mut root_cert_store = RootCertStore::empty();
+            tls.with_root_certificates(root_cert_store)
-
+        };
-            #[cfg(feature = "rustls-native-certs")]
+
-            fn load_native_roots(store: &mut RootCertStore) -> Result<(), Error> {
+        let tls = if let Some(identity) = self.identity {
-                let native_certs = rustls_native_certs::load_native_certs().map_err(error::tls)?;
+            let (client_certificates, private_key) = identity.rustls_tls;
-                let mut valid_count = 0;
+            tls.with_client_auth_cert(client_certificates, private_key)
-                let mut invalid_count = 0;
+                .map_err(error::tls)?
-                for cert in native_certs {
+        } else {
-                    match store.add(&rustls::Certificate(cert.0)) {
+            tls.with_no_client_auth()
-                        Ok(_) => valid_count += 1,
-                        Err(err) => {
-                            #[cfg(feature = "tracing")]
-                            tracing::debug!("certificate parsing failed: {:?}", err);
-                            invalid_count += 1;
-                        }
-                    }
-                }
-                #[cfg(feature = "tracing")]
-                tracing::debug!(
-                    "loaded platform certs with {valid_count} valid and {invalid_count} invalid certs"
-                );
-                Ok(())
-            }
-
-            #[cfg(feature = "webpki-roots")]
-            fn load_webpki_roots(store: &mut RootCertStore) {
-                store.add_server_trust_anchors(webpki_roots::TLS_SERVER_ROOTS.0.iter().map(|ta| {
-                    rustls::OwnedTrustAnchor::from_subject_spki_name_constraints(
-                        ta.subject,
-                        ta.spki,
-                        ta.name_constraints,
-                    )
-                }));
-            }
-
-            match self.cert_store {
-                CertificateStore::Default => {
-                    #[cfg(feature = "rustls-native-certs")]
-                    load_native_roots(&mut root_cert_store)?;
-                    #[cfg(all(not(feature = "rustls-native-certs"), feature = "webpki-roots"))]
-                    load_webpki_roots(&mut root_cert_store);
-                }
-                #[cfg(feature = "webpki-roots")]
-                CertificateStore::WebpkiRoots => {
-                    load_webpki_roots(&mut root_cert_store);
-                }
-                CertificateStore::None => {}
-            }
-            for cert in self.root_certs {
-                for rustls_cert in cert.rustls {
-                    root_cert_store.add(&rustls_cert).map_err(error::tls)?;
-                }
-            }
-
-            tls.with_custom_certificate_verifier(Arc::new(WebPkiVerifier::new(
-                root_cert_store,
-                None,
-            )))
         };
-        let tls = tls.with_no_client_auth();
 
         Ok(TlsParameters {
             connector: InnerTlsParameters::RustlsTls(Arc::new(tls)),
@@ -484,14 +543,14 @@ impl TlsParameters {
     }
 }
 
-/// 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,
 }
@@ -510,7 +569,7 @@ impl Certificate {
             #[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,
         })
@@ -530,10 +589,8 @@ impl Certificate {
 
             let mut pem = Cursor::new(pem);
             rustls_pemfile::certs(&mut pem)
+                .collect::<io::Result<Vec<_>>>()
                 .map_err(|_| error::tls("invalid certificates"))?
-                .into_iter()
-                .map(rustls::Certificate)
-                .collect::<Vec<_>>()
         };
 
         Ok(Self {
@@ -553,20 +610,144 @@ 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],
+        mut key: &[u8],
+    ) -> Result<(Vec<CertificateDer<'static>>, PrivateKeyDer<'static>), Error> {
+        let key = rustls_pemfile::private_key(&mut key)
+            .map_err(error::tls)?
+            .ok_or_else(|| error::tls("no private key found"))?;
+        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,
-        _end_entity: &rustls::Certificate,
+        end_entity: &CertificateDer<'_>,
-        _intermediates: &[rustls::Certificate],
+        intermediates: &[CertificateDer<'_>],
-        _server_name: &ServerName,
+        server_name: &ServerName<'_>,
-        _scts: &mut dyn Iterator<Item = &[u8]>,
         _ocsp_response: &[u8],
-        _now: SystemTime,
+        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/connection_url.rs

@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use url::Url;
 
 #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
@@ -62,7 +64,7 @@ impl TransportBuilder for AsyncSmtpTransportBuilder {
     }
 }
 
-/// Create a new SmtpTransportBuilder or AsyncSmtpTransportBuilder from a connection URL
+/// 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
@@ -84,26 +86,26 @@ pub(crate) fn from_connection_url<B: TransportBuilder>(connection_url: &str) ->
         ("smtp", Some("required")) => {
             builder = builder
                 .port(connection_url.port().unwrap_or(SUBMISSION_PORT))
-                .tls(Tls::Required(TlsParameters::new(host.into())?))
+                .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())?))
+                .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())?))
+                .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 {
@@ -112,7 +114,16 @@ pub(crate) fn from_connection_url<B: TransportBuilder>(connection_url: &str) ->
     }
 
     if let Some(password) = connection_url.password() {
-        let credentials = Credentials::new(connection_url.username().into(), password.into());
+        let percent_decode = |s: &str| {
+            percent_encoding::percent_decode_str(s)
+                .decode_utf8()
+                .map(Cow::into_owned)
+                .map_err(error::connection)
+        };
+        let credentials = Credentials::new(
+            percent_decode(connection_url.username())?,
+            percent_decode(password)?,
+        );
         builder = builder.credentials(credentials);
     }
 

src/transport/smtp/error.rs

@@ -119,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);
         }
 
@@ -129,22 +129,22 @@ 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", feature = "boring-tls"))]
             Kind::Tls => f.write_str("tls error")?,
-            Kind::Transient(ref code) => {
+            Kind::Transient(code) => {
                 write!(f, "transient error ({code})")?;
             }
-            Kind::Permanent(ref code) => {
+            Kind::Permanent(code) => {
                 write!(f, "permanent error ({code})")?;
             }
-        };
+        }
 
-        if let Some(ref e) = self.inner.source {
+        if let Some(e) = &self.inner.source {
             write!(f, ": {e}")?;
         }
 

src/transport/smtp/extension.rs

@@ -4,7 +4,6 @@ use std::{
     collections::HashSet,
     fmt::{self, Display, Formatter},
     net::{Ipv4Addr, Ipv6Addr},
-    result::Result,
 };
 
 use crate::transport::smtp::{
@@ -53,10 +52,10 @@ impl Default for ClientId {
 
 impl Display for ClientId {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match *self {
+        match self {
-            Self::Domain(ref value) => f.write_str(value),
+            Self::Domain(value) => f.write_str(value),
-            Self::Ipv4(ref value) => write!(f, "[{value}]"),
+            Self::Ipv4(value) => write!(f, "[{value}]"),
-            Self::Ipv6(ref value) => write!(f, "[IPv6:{value}]"),
+            Self::Ipv6(value) => write!(f, "[IPv6:{value}]"),
         }
     }
 }
@@ -93,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}"),
         }
     }
 }
@@ -130,9 +129,8 @@ impl Display for ServerInfo {
 impl ServerInfo {
     /// Parses a EHLO response to create a `ServerInfo`
     pub fn from_response(response: &Response) -> Result<ServerInfo, Error> {
-        let name = match response.first_word() {
+        let Some(name) = response.first_word() else {
-            Some(name) => name,
+            return Err(error::response("Could not read server name"));
-            None => return Err(error::response("Could not read server name")),
         };
 
         let mut features: HashSet<Extension> = HashSet::new();
@@ -170,7 +168,7 @@ impl ServerInfo {
                     }
                 }
                 _ => (),
-            };
+            }
         }
 
         Ok(ServerInfo {
@@ -227,16 +225,16 @@ pub enum MailParameter {
 
 impl Display for MailParameter {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match *self {
+        match self {
-            MailParameter::Body(ref value) => write!(f, "BODY={value}"),
+            MailParameter::Body(value) => write!(f, "BODY={value}"),
             MailParameter::Size(size) => write!(f, "SIZE={size}"),
             MailParameter::SmtpUtfEight => f.write_str("SMTPUTF8"),
             MailParameter::Other {
-                ref keyword,
+                keyword,
-                value: Some(ref value),
+                value: Some(value),
             } => write!(f, "{}={}", keyword, XText(value)),
             MailParameter::Other {
-                ref keyword,
+                keyword,
                 value: None,
             } => f.write_str(keyword),
         }
@@ -277,13 +275,13 @@ pub enum RcptParameter {
 
 impl Display for RcptParameter {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match *self {
+        match &self {
             RcptParameter::Other {
-                ref keyword,
+                keyword,
-                value: Some(ref value),
+                value: Some(value),
             } => write!(f, "{keyword}={}", XText(value)),
             RcptParameter::Other {
-                ref keyword,
+                keyword,
                 value: None,
             } => f.write_str(keyword),
         }
@@ -292,14 +290,8 @@ impl Display for RcptParameter {
 
 #[cfg(test)]
 mod test {
-
-    use std::collections::HashSet;
-
     use super::*;
-    use crate::transport::smtp::{
+    use crate::transport::smtp::response::{Category, Code, Detail, Severity};
-        authentication::Mechanism,
-        response::{Category, Code, Detail, Response, Severity},
-    };
 
     #[test]
     fn test_clientid_fmt() {

src/transport/smtp/mod.rs

@@ -26,43 +26,17 @@
 //!
 //! The relay server can be the local email server, a specific host or a third-party service.
 //!
-//! #### Simple example
+//! #### Simple example with authentication
 //!
-//! This is the most basic example of usage:
+//! A good starting point for sending emails via SMTP relay is to
-//!
+//! do the following:
-//! ```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, SmtpTransport, Transport};
-//!
-//! let email = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
-//!     .subject("Happy new year")
-//!     .body(String::from("Be happy!"))?;
-//!
-//! // Create TLS transport on port 465
-//! let sender = SmtpTransport::relay("smtp.example.com")?.build();
-//! // Send the email via remote relay
-//! let result = sender.send(&email);
-//! assert!(result.is_ok());
-//! # Ok(())
-//! # }
-//! ```
-//!
-//! #### Authentication
-//!
-//! Example with authentication and connection pool:
 //!
 //! ```rust,no_run
 //! # #[cfg(all(feature = "builder", any(feature = "native-tls", feature = "rustls-tls")))]
 //! # fn test() -> Result<(), Box<dyn std::error::Error>> {
 //! use lettre::{
-//!     transport::smtp::{
+//!     message::header::ContentType,
-//!         authentication::{Credentials, Mechanism},
+//!     transport::smtp::authentication::{Credentials, Mechanism},
-//!         PoolConfig,
-//!     },
 //!     Message, SmtpTransport, Transport,
 //! };
 //!
@@ -71,35 +45,39 @@
 //!     .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!"))?;
 //!
-//! // Create TLS transport on port 587 with STARTTLS
+//! // Create the SMTPS transport
-//! let sender = SmtpTransport::starttls_relay("smtp.example.com")?
+//! let sender = SmtpTransport::relay("smtp.example.com")?
 //!     // Add credentials for authentication
 //!     .credentials(Credentials::new(
 //!         "username".to_owned(),
 //!         "password".to_owned(),
 //!     ))
-//!     // Configure expected authentication mechanism
+//!     // Optionally configure expected authentication mechanism
 //!     .authentication(vec![Mechanism::Plain])
-//!     // Connection pool settings
-//!     .pool_config(PoolConfig::new().max_size(20))
 //!     .build();
 //!
 //! // Send the email via remote relay
-//! let result = sender.send(&email);
+//! sender.send(&email)?;
-//! assert!(result.is_ok());
 //! # Ok(())
 //! # }
 //! ```
 //!
-//! You can specify custom TLS settings:
+//! #### Shortening configuration
+//!
+//! It can be very repetitive to ask the user for every SMTP connection parameter.
+//! In some cases this can be simplified by using a connection URI instead.
+//!
+//! For more information take a look at [`SmtpTransport::from_url`] or [`AsyncSmtpTransport::from_url`].
 //!
 //! ```rust,no_run
 //! # #[cfg(all(feature = "builder", any(feature = "native-tls", feature = "rustls-tls")))]
 //! # fn test() -> Result<(), Box<dyn std::error::Error>> {
 //! use lettre::{
-//!     transport::smtp::client::{Tls, TlsParameters},
+//!     message::header::ContentType,
+//!     transport::smtp::authentication::{Credentials, Mechanism},
 //!     Message, SmtpTransport, Transport,
 //! };
 //!
@@ -108,25 +86,106 @@
 //!     .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!"))?;
 //!
-//! // Custom TLS configuration
+//! // Create the SMTPS transport
-//! let tls = TlsParameters::builder("smtp.example.com".to_owned())
+//! let sender = SmtpTransport::from_url("smtps://username:password@smtp.example.com")?.build();
-//!     .dangerous_accept_invalid_certs(true)
+//!
+//! // Send the email via remote relay
+//! sender.send(&email)?;
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! #### Advanced configuration with custom TLS settings
+//!
+//! ```rust,no_run
+//! # #[cfg(all(feature = "builder", any(feature = "native-tls", feature = "rustls-tls")))]
+//! # fn test() -> Result<(), Box<dyn std::error::Error>> {
+//! use std::fs;
+//!
+//! use lettre::{
+//!     message::header::ContentType,
+//!     transport::smtp::client::{Certificate, Tls, TlsParameters},
+//!     Message, SmtpTransport, Transport,
+//! };
+//!
+//! let email = Message::builder()
+//!     .from("NoBody <nobody@domain.tld>".parse()?)
+//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
+//!     .to("Hei <hei@domain.tld>".parse()?)
+//!     .subject("Happy new year")
+//!     .header(ContentType::TEXT_PLAIN)
+//!     .body(String::from("Be happy!"))?;
+//!
+//! // Custom TLS configuration - Use a self signed certificate
+//! let cert = fs::read("self-signed.crt")?;
+//! let cert = Certificate::from_pem(&cert)?;
+//! let tls = TlsParameters::builder(/* TLS SNI value */ "smtp.example.com".to_owned())
+//!     .add_root_certificate(cert)
 //!     .build()?;
 //!
-//! // Create TLS transport on port 465
+//! // Create the SMTPS transport
 //! let sender = SmtpTransport::relay("smtp.example.com")?
-//!     // Custom TLS configuration
+//!     .tls(Tls::Wrapper(tls))
-//!     .tls(Tls::Required(tls))
 //!     .build();
 //!
 //! // Send the email via remote relay
-//! let result = sender.send(&email);
+//! sender.send(&email)?;
-//! assert!(result.is_ok());
 //! # Ok(())
 //! # }
 //! ```
+//!
+//! #### Connection pooling
+//!
+//! [`SmtpTransport`] and [`AsyncSmtpTransport`] store connections in
+//! a connection pool by default. This avoids connecting and disconnecting
+//! from the relay server for every message the application tries to send. For the connection pool
+//! to work the instance of the transport **must** be reused.
+//! In a webserver context it may go about this:
+//!
+//! ```rust,no_run
+//! # #[cfg(all(feature = "builder", any(feature = "native-tls", feature = "rustls-tls")))]
+//! # fn test() {
+//! use lettre::{
+//!     message::header::ContentType,
+//!     transport::smtp::{authentication::Credentials, PoolConfig},
+//!     Message, SmtpTransport, Transport,
+//! };
+//! #
+//! # type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
+//!
+//! /// The global application state
+//! #[derive(Debug)]
+//! struct AppState {
+//!     smtp: SmtpTransport,
+//!     // ... other global application parameters
+//! }
+//!
+//! impl AppState {
+//!     pub fn new(smtp_url: &str) -> Result<Self> {
+//!         let smtp = SmtpTransport::from_url(smtp_url)?.build();
+//!         Ok(Self { smtp })
+//!     }
+//! }
+//!
+//! fn handle_request(app_state: &AppState) -> Result<String> {
+//!     let email = Message::builder()
+//!         .from("NoBody <nobody@domain.tld>".parse()?)
+//!         .reply_to("Yuin <yuin@domain.tld>".parse()?)
+//!         .to("Hei <hei@domain.tld>".parse()?)
+//!         .subject("Happy new year")
+//!         .header(ContentType::TEXT_PLAIN)
+//!         .body(String::from("Be happy!"))?;
+//!
+//!     // Send the email via remote relay
+//!     app_state.smtp.send(&email)?;
+//!
+//!     Ok("The email has successfully been sent!".to_owned())
+//! }
+//! # }
+//! ```
 
 use std::time::Duration;
 

src/transport/smtp/pool/async_impl.rs

@@ -2,7 +2,7 @@ use std::{
     fmt::{self, Debug},
     mem,
     ops::{Deref, DerefMut},
-    sync::Arc,
+    sync::{Arc, OnceLock},
     time::{Duration, Instant},
 };
 
@@ -10,7 +10,6 @@ use futures_util::{
     lock::Mutex,
     stream::{self, StreamExt},
 };
-use once_cell::sync::OnceCell;
 
 use super::{
     super::{client::AsyncSmtpConnection, Error},
@@ -22,7 +21,7 @@ pub struct Pool<E: Executor> {
     config: PoolConfig,
     connections: Mutex<Vec<ParkedConnection>>,
     client: AsyncSmtpClient<E>,
-    handle: OnceCell<E::Handle>,
+    handle: OnceLock<E::Handle>,
 }
 
 struct ParkedConnection {
@@ -41,7 +40,7 @@ impl<E: Executor> Pool<E> {
             config,
             connections: Mutex::new(Vec::new()),
             client,
-            handle: OnceCell::new(),
+            handle: OnceLock::new(),
         });
 
         {
@@ -79,7 +78,7 @@ impl<E: Executor> Pool<E> {
 
                             #[cfg(feature = "tracing")]
                             let mut created = 0;
-                            for _ in count..=(min_idle as usize) {
+                            for _ in count..(min_idle as usize) {
                                 let conn = match pool.client.connection().await {
                                     Ok(conn) => conn,
                                     Err(err) => {
@@ -110,7 +109,7 @@ impl<E: Executor> Pool<E> {
                                 #[cfg(feature = "tracing")]
                                 tracing::debug!("dropped {} idle connections", dropped.len());
 
-                                abort_concurrent(dropped.into_iter().map(|conn| conn.unpark()))
+                                abort_concurrent(dropped.into_iter().map(ParkedConnection::unpark))
                                     .await;
                             }
                         }
@@ -230,7 +229,7 @@ impl<E: Executor> Drop for Pool<E> {
                 handle.shutdown().await;
             }
 
-            abort_concurrent(connections.into_iter().map(|conn| conn.unpark())).await;
+            abort_concurrent(connections.into_iter().map(ParkedConnection::unpark)).await;
         });
     }
 }

src/transport/smtp/pool/sync_impl.rs

@@ -72,7 +72,7 @@ impl Pool {
 
                         #[cfg(feature = "tracing")]
                         let mut created = 0;
-                        for _ in count..=(min_idle as usize) {
+                        for _ in count..(min_idle as usize) {
                             let conn = match pool.client.connection() {
                                 Ok(conn) => conn,
                                 Err(err) => {
@@ -109,6 +109,7 @@ impl Pool {
                             }
                         }
 
+                        drop(pool);
                         thread::sleep(idle_timeout);
                     }
                 })

src/transport/smtp/response.rs

@@ -5,7 +5,6 @@ use std::{
     fmt::{Display, Formatter, Result},
     result,
     str::FromStr,
-    string::ToString,
 };
 
 use nom::{
@@ -132,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
@@ -317,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";

src/transport/smtp/transport.rs

@@ -1,6 +1,6 @@
 #[cfg(feature = "pool")]
 use std::sync::Arc;
-use std::time::Duration;
+use std::{fmt::Debug, time::Duration};
 
 #[cfg(feature = "pool")]
 use super::pool::sync_impl::Pool;
@@ -11,7 +11,31 @@ use super::{ClientId, Credentials, Error, Mechanism, Response, SmtpConnection, S
 use super::{Tls, TlsParameters, SUBMISSIONS_PORT, SUBMISSION_PORT};
 use crate::{address::Envelope, Transport};
 
-/// Sends emails using the SMTP protocol
+/// Synchronously send emails using the SMTP protocol
+///
+/// `SmtpTransport` is the primary way for communicating
+/// with SMTP relay servers to send email messages. It holds the
+/// client connect configuration and creates new connections
+/// as necessary.
+///
+/// # Connection pool
+///
+/// When the `pool` feature is enabled (default), `SmtpTransport` maintains a
+/// connection pool to manage SMTP connections. The pool:
+///
+/// - Establishes a new connection when sending a message.
+/// - Recycles connections internally after a message is sent.
+/// - Reuses connections for subsequent messages, reducing connection setup overhead.
+///
+/// The connection pool can grow to hold multiple SMTP connections if multiple
+/// emails are sent concurrently, as SMTP does not support multiplexing within a
+/// single connection.
+///
+/// However, **connection reuse is not possible** if the `SmtpTransport` instance
+/// is dropped after every email send operation. You must reuse the instance
+/// of this struct for the connection pool to be of any use.
+///
+/// To customize connection pool settings, use [`SmtpTransportBuilder::pool_config`].
 #[cfg_attr(docsrs, doc(cfg(feature = "smtp-transport")))]
 #[derive(Clone)]
 pub struct SmtpTransport {
@@ -32,12 +56,20 @@ impl Transport for SmtpTransport {
         let result = conn.send(envelope, email)?;
 
         #[cfg(not(feature = "pool"))]
-        conn.quit()?;
+        conn.abort();
 
         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
     ///
@@ -107,54 +139,72 @@ impl SmtpTransport {
 
     /// Creates a `SmtpTransportBuilder` from a connection URL
     ///
-    /// The protocol, credentials, host and port can be provided in a single URL.
+    /// The protocol, credentials, host, port and EHLO name can be provided
-    /// Use the scheme `smtp` for an unencrypted relay (optionally in combination with the
+    /// in a single URL. This may be simpler than having to configure SMTP
-    /// `tls` parameter to allow/require STARTTLS) or `smtps` for SMTP over TLS.
+    /// through multiple configuration parameters and then having to pass
-    /// The path section of the url can be used to set an alternative name for
+    /// those options to lettre.
-    /// 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>
+    /// The URL is created in the following way:
-    ///   <thead>
+    /// `scheme://user:pass@hostname:port/ehlo-name?tls=TLS`.
-    ///     <tr>
+    ///
-    ///       <th>scheme</th>
+    /// `user` (Username) and `pass` (Password) are optional in case the
-    ///       <th>tls parameter</th>
+    /// SMTP relay doesn't require authentication. When `port` is not
-    ///       <th>example</th>
+    /// configured it is automatically determined based on the `scheme`.
-    ///       <th>remarks</th>
+    /// `ehlo-name` optionally overwrites the hostname sent for the EHLO
-    ///     </tr>
+    /// command. `TLS` controls whether STARTTLS is simply enabled
-    ///   </thead>
+    /// (`opportunistic` - not enough to prevent man-in-the-middle attacks)
-    ///   <tbody>
+    /// or `required` (require the server to upgrade the connection to
-    ///     <tr>
+    /// STARTTLS, otherwise fail on suspicion of main-in-the-middle attempt).
-    ///      <td>smtps</td>
+    ///
-    ///      <td>-</td>
+    /// Use the following table to construct your SMTP url:
-    ///      <td>smtps://smtp.example.com</td>
+    ///
-    ///      <td>SMTP over TLS, recommended method</td>
+    /// | scheme  | `tls` query parameter | example                                            | default port | remarks                                                                                                                               |
-    ///     </tr>
+    /// | ------- | --------------------- | -------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------------- |
-    ///     <tr>
+    /// | `smtps` | unset                 | `smtps://user:pass@hostname:port`                  | 465          | SMTP over TLS, recommended method                                                                                                     |
-    ///      <td>smtp</td>
+    /// | `smtp`  | `required`            | `smtp://user:pass@hostname:port?tls=required`      | 587          | SMTP with STARTTLS required, when SMTP over TLS is not available                                                                      |
-    ///      <td>required</td>
+    /// | `smtp`  | `opportunistic`       | `smtp://user:pass@hostname:port?tls=opportunistic` | 587          | SMTP with optionally STARTTLS when supported by the server. Not suitable for production use: vulnerable to a man-in-the-middle attack |
-    ///      <td>smtp://smtp.example.com?tls=required</td>
+    /// | `smtp`  | unset                 | `smtp://user:pass@hostname:port`                   | 587          | Always unencrypted SMTP. Not suitable for production use: sends all data unencrypted                                                  |
-    ///      <td>SMTP with STARTTLS required, when SMTP over TLS is not available</td>
+    ///
-    ///     </tr>
+    /// IMPORTANT: some parameters like `user` and `pass` cannot simply
-    ///     <tr>
+    /// be concatenated to construct the final URL because special characters
-    ///      <td>smtp</td>
+    /// contained within the parameter may confuse the URL decoder.
-    ///      <td>opportunistic</td>
+    /// Manually URL encode the parameters before concatenating them or use
-    ///      <td>smtp://smtp.example.com?tls=opportunistic</td>
+    /// a proper URL encoder, like the following cargo script:
-    ///      <td>
+    ///
-    ///         SMTP with optionally STARTTLS when supported by the server.
+    /// ```rust
-    ///         Caution: this method is vulnerable to a man-in-the-middle attack.
+    /// # let _ = r#"
-    ///         Not recommended for production use.
+    /// #!/usr/bin/env cargo
-    ///       </td>
+    ///
-    ///     </tr>
+    /// //! ```cargo
-    ///     <tr>
+    /// //! [dependencies]
-    ///      <td>smtp</td>
+    /// //! url = "2"
-    ///      <td>-</td>
+    /// //! ```
-    ///      <td>smtp://smtp.example.com</td>
+    /// # "#;
-    ///      <td>Unencrypted SMTP, not recommended for production use.</td>
+    ///
-    ///     </tr>
+    /// use url::Url;
-    ///   </tbody>
+    ///
-    /// </table>
+    /// fn main() {
+    ///     // don't touch this line
+    ///     let mut url = Url::parse("foo://bar").unwrap();
+    ///
+    ///     // configure the scheme (`smtp` or `smtps`) here.
+    ///     url.set_scheme("smtps").unwrap();
+    ///     // configure the username and password.
+    ///     // remove the following two lines if unauthenticated.
+    ///     url.set_username("username").unwrap();
+    ///     url.set_password(Some("password")).unwrap();
+    ///     // configure the hostname
+    ///     url.set_host(Some("smtp.example.com")).unwrap();
+    ///     // configure the port - only necessary if using a non-default port
+    ///     url.set_port(Some(465)).unwrap();
+    ///     // configure the EHLO name
+    ///     url.set_path("ehlo-name");
+    ///
+    ///     println!("{url}");
+    /// }
+    /// ```
+    ///
+    /// The connection URL can then be used in the following way:
     ///
     /// ```rust,no_run
     /// use lettre::{
@@ -162,6 +212,7 @@ impl SmtpTransport {
     ///     SmtpTransport, Transport,
     /// };
     ///
+    /// # 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())
@@ -172,15 +223,12 @@ impl SmtpTransport {
     ///     .unwrap();
     ///
     /// // Open a remote connection to example
-    /// let mailer = SmtpTransport::from_url("smtps://username:password@smtp.example.com:465")
+    /// let mailer = SmtpTransport::from_url("smtps://username:password@smtp.example.com")?.build();
-    ///     .unwrap()
-    ///     .build();
     ///
     /// // Send the email
-    /// match mailer.send(&email) {
+    /// mailer.send(&email)?;
-    ///     Ok(_) => println!("Email sent successfully!"),
+    /// # Ok(())
-    ///     Err(e) => panic!("Could not send email: {e:?}"),
+    /// # }
-    /// }
     /// ```
     #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
     #[cfg_attr(
@@ -238,7 +286,7 @@ impl SmtpTransportBuilder {
         self
     }
 
-    /// Set the authentication mechanism to use
+    /// Set the authentication credentials to use
     pub fn credentials(mut self, credentials: Credentials) -> Self {
         self.info.credentials = Some(credentials);
         self
@@ -257,12 +305,34 @@ impl SmtpTransportBuilder {
     }
 
     /// Set the port to use
+    ///
+    /// # ⚠️⚠️⚠️ You probably don't need to call this method ⚠️⚠️⚠️
+    ///
+    /// lettre usually picks the correct `port` when building
+    /// [`SmtpTransport`] using [`SmtpTransport::relay`] or
+    /// [`SmtpTransport::starttls_relay`].
+    ///
+    /// # Errors
+    ///
+    /// Using the incorrect `port` and [`Self::tls`] combination may
+    /// lead to hard to debug IO errors coming from the TLS library.
     pub fn port(mut self, port: u16) -> Self {
         self.info.port = port;
         self
     }
 
     /// Set the TLS settings to use
+    ///
+    /// # ⚠️⚠️⚠️ You probably don't need to call this method ⚠️⚠️⚠️
+    ///
+    /// By default lettre chooses the correct `tls` configuration when
+    /// building [`SmtpTransport`] using [`SmtpTransport::relay`] or
+    /// [`SmtpTransport::starttls_relay`].
+    ///
+    /// # Errors
+    ///
+    /// Using the wrong [`Tls`] and [`Self::port`] combination may
+    /// lead to hard to debug IO errors coming from the TLS library.
     #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
     #[cfg_attr(
         docsrs,
@@ -309,9 +379,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 {
+        let tls_parameters = match &self.info.tls {
             #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
-            Tls::Wrapper(ref tls_parameters) => Some(tls_parameters),
+            Tls::Wrapper(tls_parameters) => Some(tls_parameters),
             _ => None,
         };
 
@@ -325,13 +395,13 @@ impl SmtpClient {
         )?;
 
         #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
-        match self.info.tls {
+        match &self.info.tls {
-            Tls::Opportunistic(ref tls_parameters) => {
+            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)?;
             }
             _ => (),
@@ -373,6 +443,22 @@ mod tests {
         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();

src/transport/smtp/util.rs

@@ -6,7 +6,7 @@ use std::fmt::{Display, Formatter, Result as FmtResult};
 #[derive(Debug)]
 pub struct XText<'a>(pub &'a str);
 
-impl<'a> Display for XText<'a> {
+impl Display for XText<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         let mut rest = self.0;
         while let Some(idx) = rest.find(|c| c < '!' || c == '+' || c == '=') {
@@ -38,9 +38,7 @@ mod tests {
             ("bjørn", "bjørn"),
             ("Ø+= ❤️‰", "Ø+2B+3D+20❤️‰"),
             ("+", "+2B"),
-        ]
+        ] {
-        .iter()
-        {
             assert_eq!(format!("{}", XText(input)), (*expect).to_owned());
         }
     }

src/transport/stub/mod.rs

@@ -11,7 +11,9 @@
 //! ```rust
 //! # #[cfg(feature = "builder")]
 //! # {
-//! use lettre::{transport::stub::StubTransport, Message, Transport};
+//! use lettre::{
+//!     message::header::ContentType, transport::stub::StubTransport, Message, Transport,
+//! };
 //!
 //! # use std::error::Error;
 //! # fn try_main() -> Result<(), Box<dyn Error>> {
@@ -20,11 +22,11 @@
 //!     .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!"))?;
 //!
 //! let mut sender = StubTransport::new_ok();
-//! let result = sender.send(&email);
+//! sender.send(&email)?;
-//! assert!(result.is_ok());
 //! assert_eq!(
 //!     sender.messages(),
 //!     vec![(