Prepare 0.10.3 (#860 )

Add Content-Type to all examples sending a basic text/plain message (#859 )
mailbox: replace serialize_str(&self.to_string()) with collect_str(self) (#858 )
2023-02-20 11:56:28 +01:00 · 2023-02-14 17:54:05 +00:00 · 2023-02-14 18:35:29 +01:00 · 2023-02-14 18:33:10 +01:00 · 2023-02-14 18:11:42 +01:00 · 2023-01-29 14:58:41 +01:00
53 changed files with 1162 additions and 555 deletions
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -13,7 +13,7 @@ env:

 jobs:
  rustfmt:
-    name: rustfmt / nightly-2022-02-11
+    name: rustfmt / nightly-2022-11-12
    runs-on: ubuntu-latest

    steps:
@@ -22,7 +22,7 @@ jobs:

      - name: Install rust
        run: |
-          rustup default nightly-2022-02-11
+          rustup default nightly-2022-11-12
          rustup component add rustfmt

      - name: cargo fmt
@@ -52,17 +52,11 @@ jobs:
      - name: Checkout
        uses: actions/checkout@v2

-      - name: Setup cache
-        uses: actions/cache@v2
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-          key: ${{ runner.os }}-cargo-check
-
      - name: Install rust
        run: rustup update --no-self-update stable
+
+      - name: Setup cache
+        uses: Swatinem/rust-cache@v2
      
      - name: Install cargo hack
        run: cargo install cargo-hack --debug
@@ -81,27 +75,21 @@ jobs:
            rust: stable
          - name: beta
            rust: beta
-          - name: 1.56.0
-            rust: 1.56.0
+          - name: 1.60.0
+            rust: 1.60.0

    steps:
      - name: Checkout
        uses: actions/checkout@v2

-      - name: Setup cache
-        uses: actions/cache@v2
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-          key: ${{ runner.os }}-cargo-test-${{ matrix.rust }}
-
      - name: Install rust
        run: |
          rustup default ${{ matrix.rust }}
          rustup update --no-self-update ${{ matrix.rust }}

+      - name: Setup cache
+        uses: Swatinem/rust-cache@v2
+
      - name: Install postfix  
        run: |
          DEBIAN_FRONTEND=noninteractive sudo apt-get update
@@ -133,9 +121,12 @@ jobs:
      - name: Test with default features
        run: cargo test

-      - name: Test with all features
-        run: cargo test --all-features
+      - name: Test with all features (-native-tls)
+        run: cargo test --no-default-features --features async-std,async-std1,async-std1-rustls-tls,async-trait,base64,boring,boring-tls,builder,dkim,ed25519-dalek,email-encoding,fastrand,file-transport,file-transport-envelope,futures-io,futures-rustls,futures-util,hostname,httpdate,mime,mime03,nom,once_cell,pool,quoted_printable,rsa,rustls,rustls-native-certs,rustls-pemfile,rustls-tls,sendmail-transport,serde,serde_json,sha2,smtp-transport,socket2,tokio1,tokio1-boring-tls,tokio1-rustls-tls,tokio1_boring,tokio1_crate,tokio1_rustls,tracing,uuid,webpki-roots
  
+      - name: Test with all features (-boring-tls)
+        run: cargo test --no-default-features --features async-std,async-std1,async-std1-rustls-tls,async-trait,base64,builder,dkim,ed25519-dalek,email-encoding,fastrand,file-transport,file-transport-envelope,futures-io,futures-rustls,futures-util,hostname,httpdate,mime,mime03,native-tls,nom,once_cell,pool,quoted_printable,rsa,rustls,rustls-native-certs,rustls-pemfile,rustls-tls,sendmail-transport,serde,serde_json,sha2,smtp-transport,socket2,tokio1,tokio1-native-tls,tokio1-rustls-tls,tokio1_crate,tokio1_native_tls_crate,tokio1_rustls,tracing,uuid,webpki-roots
+
 #  coverage:
 #    name: Coverage
 #    runs-on: ubuntu-latest
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,94 @@
+<a name="v0.10.3"></a>
+### v0.10.3 (2023-02-20)
+
+#### Announcements
+
+It was found that what had been used until now as a basic lettre 0.10
+`MessageBuilder::body` example failed to mention that for maximum
+compatibility with various email clients a `Content-Type` header
+should always be present in the message.
+
+##### Before
+
+```rust
+Message::builder()
+  // [...] some headers skipped for brevity
+  .body(String::from("A plaintext or html body"))?
+```
+
+##### Patch
+
+```diff
+ Message::builder()
+   // [...] some headers skipped for brevity
+  .header(ContentType::TEXT_PLAIN) // or `TEXT_HTML` if the body is html
+   .body(String::from("A plaintext or html body"))?
+```
+
+#### Features
+
+* Add support for rustls-native-certs when using rustls ([#843])
+
+[#843]: https://github.com/lettre/lettre/pull/843
+
+<a name="v0.10.2"></a>
+### v0.10.2 (2023-01-29)
+
+#### Upgrade notes
+
+* MSRV is now 1.60 ([#828])
+
+#### Features
+
+* Allow providing a custom `tokio` stream for `AsyncSmtpTransport` ([#805])
+* Return whole SMTP error message ([#821])
+
+#### Bug fixes
+
+* Mailbox displays wrongly when containing a comma and a non-ascii char in its name ([#827])
+* Require `quoted_printable` ^0.4.6 in order to fix encoding of tabs and spaces at the end of line ([#837])
+
+#### Misc
+
+* Increase tracing ([#848])
+* Bump `idna` to 0.3 ([#816])
+* Update `base64` to 0.21 ([#840] and [#851])
+* Update `rsa` to 0.8 ([#829] and [#852])
+
+[#805]: https://github.com/lettre/lettre/pull/805
+[#816]: https://github.com/lettre/lettre/pull/816
+[#821]: https://github.com/lettre/lettre/pull/821
+[#827]: https://github.com/lettre/lettre/pull/827
+[#828]: https://github.com/lettre/lettre/pull/828
+[#829]: https://github.com/lettre/lettre/pull/829
+[#837]: https://github.com/lettre/lettre/pull/837
+[#840]: https://github.com/lettre/lettre/pull/840
+[#848]: https://github.com/lettre/lettre/pull/848
+[#851]: https://github.com/lettre/lettre/pull/851
+[#852]: https://github.com/lettre/lettre/pull/852
+
+<a name="v0.10.1"></a>
+### v0.10.1 (2022-07-20)
+
+#### Features
+
+* Add `boring-tls` support for `SmtpTransport` and `AsyncSmtpTransport`. The latter is only supported with the tokio runtime. ([#797]) ([#798])
+* Make the minimum TLS version configurable. ([#799]) ([#800])
+
+#### Bug Fixes
+
+* Ensure connections are closed on abort. ([#801])
+* Fix SMTP dot stuffing. ([#803])
+
+[#797]: https://github.com/lettre/lettre/pull/797
+[#798]: https://github.com/lettre/lettre/pull/798
+[#799]: https://github.com/lettre/lettre/pull/799
+[#800]: https://github.com/lettre/lettre/pull/800
+[#801]: https://github.com/lettre/lettre/pull/801
+[#803]: https://github.com/lettre/lettre/pull/803
+
 <a name="v0.10.0"></a>
-### v0.10.0 (unreleased)
+### v0.10.0 (2022-06-29)

 #### Upgrade notes

--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "lettre"
 # remember to update html_root_url and README.md (Cargo.toml example and deps.rs badge)
-version = "0.10.0"
+version = "0.10.3"
 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.56"
+rust-version = "1.60"

 [badges]
 is-it-maintained-issue-resolution = { repository = "lettre/lettre" }
@@ -19,7 +19,7 @@ is-it-maintained-open-issues = { repository = "lettre/lettre" }
 maintenance = { status = "actively-developed" }

 [dependencies]
-idna = "0.2"
+idna = "0.3"
 once_cell = { version = "1", optional = true }
 tracing = { version = "0.1.16", default-features = false, features = ["std"], optional = true } # feature

@@ -27,9 +27,9 @@ tracing = { version = "0.1.16", default-features = false, features = ["std"], op
 httpdate = { version = "1", optional = true }
 mime = { version = "0.3.4", optional = true }
 fastrand = { version = "1.4", optional = true }
-quoted_printable = { version = "0.4", optional = true }
-base64 = { version = "0.13", optional = true }
-email-encoding = { version = "0.1.1", optional = true }
+quoted_printable = { version = "0.4.6", optional = true }
+base64 = { version = "0.21", optional = true }
+email-encoding = { version = "0.2", optional = true }

 # file transport
 uuid = { version = "1", features = ["v4"], optional = true }
@@ -45,7 +45,9 @@ socket2 = { version = "0.4.4", optional = true }
 native-tls = { version = "0.2", optional = true } # feature
 rustls = { version = "0.20", features = ["dangerous_configuration"], optional = true }
 rustls-pemfile = { version = "1", optional = true }
+rustls-native-certs = { version = "0.6.2", optional = true }
 webpki-roots = { version = "0.22", optional = true }
+boring = { version = "2.0.0", optional = true }

 # async
 futures-io = { version = "0.3.7", optional = true }
@@ -53,27 +55,27 @@ futures-util = { version = "0.3.7", default-features = false, features = ["io"],
 async-trait = { version = "0.1", optional = true }

 ## async-std
-async-std = { version = "1.8", optional = true, features = ["unstable"] }
+async-std = { version = "1.8", optional = true }
 #async-native-tls = { version = "0.3.3", optional = true }
 futures-rustls = { version = "0.22", optional = true }

 ## tokio
-tokio1_crate = { package = "tokio", version = "1", features = ["fs", "rt", "process", "time", "net", "io-util"], optional = true }
+tokio1_crate = { package = "tokio", version = "1", optional = true }
 tokio1_native_tls_crate = { package = "tokio-native-tls", version = "0.3", optional = true }
 tokio1_rustls = { package = "tokio-rustls", version = "0.23", optional = true }
+tokio1_boring = { package = "tokio-boring", version = "2.1.4", optional = true }

 ## dkim
-sha2 = { version = "0.10", optional = true }
-rsa = { version = "0.6.0", optional = true }
+sha2 = { version = "0.10", optional = true, features = ["oid"] }
+rsa = { version = "0.8", optional = true }
 ed25519-dalek = { version = "1.0.1", optional = true }
-regex = { version = "1", default-features = false, features = ["std"], optional = true }

 # email formats
 email_address = { version = "0.2.1", default-features = false }

 [dev-dependencies]
 pretty_assertions = "1"
-criterion = "0.3"
+criterion = "0.4"
 tracing = { version = "0.1.16", default-features = false, features = ["std"] }
 tracing-subscriber = "0.3"
 glob = "0.3"
@@ -81,7 +83,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.23"
+maud = "0.24"

 [[bench]]
 harness = false
@@ -93,15 +95,17 @@ builder = ["httpdate", "mime", "fastrand", "quoted_printable", "email-encoding"]
 mime03 = ["mime"]

 # transports
-file-transport = ["uuid"]
+file-transport = ["uuid", "tokio1_crate?/fs", "tokio1_crate?/io-util"]
 file-transport-envelope = ["serde", "serde_json", "file-transport"]
-sendmail-transport = []
-smtp-transport = ["base64", "nom", "socket2", "once_cell"]
+sendmail-transport = ["tokio1_crate?/process", "tokio1_crate?/io-util", "async-std?/unstable"]
+smtp-transport = ["base64", "nom", "socket2", "once_cell", "tokio1_crate?/rt", "tokio1_crate?/time", "tokio1_crate?/net"]

 pool = ["futures-util"]

 rustls-tls = ["webpki-roots", "rustls", "rustls-pemfile"]

+boring-tls = ["boring"]
+
 # async
 async-std1 = ["async-std", "async-trait", "futures-io", "futures-util"]
 #async-std1-native-tls = ["async-std1", "native-tls", "async-native-tls"]
@@ -109,8 +113,9 @@ async-std1-rustls-tls = ["async-std1", "rustls-tls", "futures-rustls"]
 tokio1 = ["tokio1_crate", "async-trait", "futures-io", "futures-util"]
 tokio1-native-tls = ["tokio1", "native-tls", "tokio1_native_tls_crate"]
 tokio1-rustls-tls = ["tokio1", "rustls-tls", "tokio1_rustls"]
+tokio1-boring-tls = ["tokio1", "boring-tls", "tokio1_boring"]

-dkim = ["base64", "sha2", "rsa", "ed25519-dalek", "regex", "once_cell"]
+dkim = ["base64", "sha2", "rsa", "ed25519-dalek"]

 [package.metadata.docs.rs]
 all-features = true
--- a/README.md
+++ b/README.md
@@ -28,8 +28,8 @@
 </div>

 <div align="center">
-  <a href="https://deps.rs/crate/lettre/0.10.0">
-    <img src="https://deps.rs/crate/lettre/0.10.0/status.svg"
+  <a href="https://deps.rs/crate/lettre/0.10.3">
+    <img src="https://deps.rs/crate/lettre/0.10.3/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.56, but this could change at any time either from
+the minimum supported Rust version is 1.60, 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.56.0 or newer.
+This library requires Rust 1.60 or newer.
 To use this library, add the following to your `Cargo.toml`:

 ```toml
@@ -67,6 +67,7 @@ lettre = "0.10"
 ```

 ```rust,no_run
+use lettre::message::header::ContentType;
 use lettre::transport::smtp::authentication::Credentials;
 use lettre::{Message, SmtpTransport, Transport};

@@ -75,10 +76,11 @@ let email = Message::builder()
    .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
    .to("Hei <hei@domain.tld>".parse().unwrap())
    .subject("Happy new year")
+    .header(ContentType::TEXT_PLAIN)
    .body(String::from("Be happy!"))
    .unwrap();

-let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
+let creds = Credentials::new("smtp_username".to_owned(), "smtp_password".to_owned());

 // Open a remote connection to gmail
 let mailer = SmtpTransport::relay("smtp.gmail.com")
--- a/examples/asyncstd1_smtp_starttls.rs
+++ b/examples/asyncstd1_smtp_starttls.rs
@@ -1,6 +1,6 @@
 use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncStd1Executor,
-    AsyncTransport, Message,
+    message::header::ContentType, transport::smtp::authentication::Credentials, AsyncSmtpTransport,
+    AsyncStd1Executor, AsyncTransport, Message,
 };

 #[async_std::main]
@@ -12,10 +12,11 @@ async fn main() {
        .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
        .to("Hei <hei@domain.tld>".parse().unwrap())
        .subject("Happy new async year")
+        .header(ContentType::TEXT_PLAIN)
        .body(String::from("Be happy with async!"))
        .unwrap();

-    let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
+    let creds = Credentials::new("smtp_username".to_owned(), "smtp_password".to_owned());

    // Open a remote connection to gmail using STARTTLS
    let mailer: AsyncSmtpTransport<AsyncStd1Executor> =
@@ -27,6 +28,6 @@ async fn main() {
    // Send the email
    match mailer.send(email).await {
        Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
+        Err(e) => panic!("Could not send email: {e:?}"),
    }
 }
--- a/examples/asyncstd1_smtp_tls.rs
+++ b/examples/asyncstd1_smtp_tls.rs
@@ -1,6 +1,6 @@
 use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncStd1Executor,
-    AsyncTransport, Message,
+    message::header::ContentType, transport::smtp::authentication::Credentials, AsyncSmtpTransport,
+    AsyncStd1Executor, AsyncTransport, Message,
 };

 #[async_std::main]
@@ -12,10 +12,11 @@ async fn main() {
        .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
        .to("Hei <hei@domain.tld>".parse().unwrap())
        .subject("Happy new async year")
+        .header(ContentType::TEXT_PLAIN)
        .body(String::from("Be happy with async!"))
        .unwrap();

-    let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
+    let creds = Credentials::new("smtp_username".to_owned(), "smtp_password".to_owned());

    // Open a remote connection to gmail
    let mailer: AsyncSmtpTransport<AsyncStd1Executor> =
@@ -27,6 +28,6 @@ async fn main() {
    // Send the email
    match mailer.send(email).await {
        Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
+        Err(e) => panic!("Could not send email: {e:?}"),
    }
 }
--- a/examples/smtp.rs
+++ b/examples/smtp.rs
@@ -1,4 +1,4 @@
-use lettre::{Message, SmtpTransport, Transport};
+use lettre::{message::header::ContentType, Message, SmtpTransport, Transport};

 fn main() {
    tracing_subscriber::fmt::init();
@@ -8,6 +8,7 @@ fn main() {
        .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
        .to("Hei <hei@domain.tld>".parse().unwrap())
        .subject("Happy new year")
+        .header(ContentType::TEXT_PLAIN)
        .body(String::from("Be happy!"))
        .unwrap();

@@ -17,6 +18,6 @@ fn main() {
    // Send the email
    match mailer.send(&email) {
        Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
+        Err(e) => panic!("Could not send email: {e:?}"),
    }
 }
--- a/examples/smtp_selfsigned.rs
+++ b/examples/smtp_selfsigned.rs
@@ -1,6 +1,7 @@
 use std::fs;

 use lettre::{
+    message::header::ContentType,
    transport::smtp::{
        authentication::Credentials,
        client::{Certificate, Tls, TlsParameters},
@@ -16,18 +17,19 @@ fn main() {
        .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
        .to("Hei <hei@domain.tld>".parse().unwrap())
        .subject("Happy new year")
+        .header(ContentType::TEXT_PLAIN)
        .body(String::from("Be happy!"))
        .unwrap();

    // Use a custom certificate stored on disk to securely verify the server's certificate
    let pem_cert = fs::read("certificate.pem").unwrap();
    let cert = Certificate::from_pem(&pem_cert).unwrap();
-    let tls = TlsParameters::builder("smtp.server.com".to_string())
+    let tls = TlsParameters::builder("smtp.server.com".to_owned())
        .add_root_certificate(cert)
        .build()
        .unwrap();

-    let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
+    let creds = Credentials::new("smtp_username".to_owned(), "smtp_password".to_owned());

    // Open a remote connection to the smtp server
    let mailer = SmtpTransport::builder_dangerous("smtp.server.com")
@@ -39,6 +41,6 @@ fn main() {
    // Send the email
    match mailer.send(&email) {
        Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
+        Err(e) => panic!("Could not send email: {e:?}"),
    }
 }
--- a/examples/smtp_starttls.rs
+++ b/examples/smtp_starttls.rs
@@ -1,4 +1,7 @@
-use lettre::{transport::smtp::authentication::Credentials, Message, SmtpTransport, Transport};
+use lettre::{
+    message::header::ContentType, transport::smtp::authentication::Credentials, Message,
+    SmtpTransport, Transport,
+};

 fn main() {
    tracing_subscriber::fmt::init();
@@ -8,10 +11,11 @@ fn main() {
        .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
        .to("Hei <hei@domain.tld>".parse().unwrap())
        .subject("Happy new year")
+        .header(ContentType::TEXT_PLAIN)
        .body(String::from("Be happy!"))
        .unwrap();

-    let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
+    let creds = Credentials::new("smtp_username".to_owned(), "smtp_password".to_owned());

    // Open a remote connection to gmail using STARTTLS
    let mailer = SmtpTransport::starttls_relay("smtp.gmail.com")
@@ -22,6 +26,6 @@ fn main() {
    // Send the email
    match mailer.send(&email) {
        Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
+        Err(e) => panic!("Could not send email: {e:?}"),
    }
 }
--- a/examples/smtp_tls.rs
+++ b/examples/smtp_tls.rs
@@ -1,4 +1,7 @@
-use lettre::{transport::smtp::authentication::Credentials, Message, SmtpTransport, Transport};
+use lettre::{
+    message::header::ContentType, transport::smtp::authentication::Credentials, Message,
+    SmtpTransport, Transport,
+};

 fn main() {
    tracing_subscriber::fmt::init();
@@ -8,10 +11,11 @@ fn main() {
        .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
        .to("Hei <hei@domain.tld>".parse().unwrap())
        .subject("Happy new year")
+        .header(ContentType::TEXT_PLAIN)
        .body(String::from("Be happy!"))
        .unwrap();

-    let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
+    let creds = Credentials::new("smtp_username".to_owned(), "smtp_password".to_owned());

    // Open a remote connection to gmail
    let mailer = SmtpTransport::relay("smtp.gmail.com")
@@ -22,6 +26,6 @@ fn main() {
    // Send the email
    match mailer.send(&email) {
        Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
+        Err(e) => panic!("Could not send email: {e:?}"),
    }
 }
--- a/examples/tokio1_smtp_starttls.rs
+++ b/examples/tokio1_smtp_starttls.rs
@@ -2,8 +2,8 @@
 // since it uses Rust 2018 crate renaming to import tokio.
 // Won't be needed in user's code.
 use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncTransport, Message,
-    Tokio1Executor,
+    message::header::ContentType, transport::smtp::authentication::Credentials, AsyncSmtpTransport,
+    AsyncTransport, Message, Tokio1Executor,
 };
 use tokio1_crate as tokio;

@@ -16,10 +16,11 @@ async fn main() {
        .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
        .to("Hei <hei@domain.tld>".parse().unwrap())
        .subject("Happy new async year")
+        .header(ContentType::TEXT_PLAIN)
        .body(String::from("Be happy with async!"))
        .unwrap();

-    let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
+    let creds = Credentials::new("smtp_username".to_owned(), "smtp_password".to_owned());

    // Open a remote connection to gmail using STARTTLS
    let mailer: AsyncSmtpTransport<Tokio1Executor> =
@@ -31,6 +32,6 @@ async fn main() {
    // Send the email
    match mailer.send(email).await {
        Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
+        Err(e) => panic!("Could not send email: {e:?}"),
    }
 }
--- a/examples/tokio1_smtp_tls.rs
+++ b/examples/tokio1_smtp_tls.rs
@@ -2,8 +2,8 @@
 // since it uses Rust 2018 crate renaming to import tokio.
 // Won't be needed in user's code.
 use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncTransport, Message,
-    Tokio1Executor,
+    message::header::ContentType, transport::smtp::authentication::Credentials, AsyncSmtpTransport,
+    AsyncTransport, Message, Tokio1Executor,
 };
 use tokio1_crate as tokio;

@@ -16,10 +16,11 @@ async fn main() {
        .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
        .to("Hei <hei@domain.tld>".parse().unwrap())
        .subject("Happy new async year")
+        .header(ContentType::TEXT_PLAIN)
        .body(String::from("Be happy with async!"))
        .unwrap();

-    let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
+    let creds = Credentials::new("smtp_username".to_owned(), "smtp_password".to_owned());

    // Open a remote connection to gmail
    let mailer: AsyncSmtpTransport<Tokio1Executor> =
@@ -31,6 +32,6 @@ async fn main() {
    // Send the email
    match mailer.send(email).await {
        Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
+        Err(e) => panic!("Could not send email: {e:?}"),
    }
 }
--- a/src/address/types.rs
+++ b/src/address/types.rs
@@ -184,7 +184,7 @@ where
        let domain = domain.as_ref();
        Address::check_domain(domain)?;

-        let serialized = format!("{}@{}", user, domain);
+        let serialized = format!("{user}@{domain}");
        Ok(Address {
            serialized,
            at_start: user.len(),
--- a/src/base64.rs
+++ b/src/base64.rs
@@ -0,0 +1,12 @@
+use ::base64::{
+    engine::{general_purpose::STANDARD, Engine},
+    DecodeError,
+};
+
+pub(crate) fn encode<T: AsRef<[u8]>>(input: T) -> String {
+    STANDARD.encode(input)
+}
+
+pub(crate) fn decode<T: AsRef<[u8]>>(input: T) -> Result<Vec<u8>, DecodeError> {
+    STANDARD.decode(input)
+}
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -6,7 +6,7 @@
 //! * Secure defaults
 //! * Async support
 //!
-//! Lettre requires Rust 1.56.0 or newer.
+//! Lettre requires Rust 1.60 or newer.
 //!
 //! ## Features
 //!
@@ -41,6 +41,15 @@
 //!
 //! NOTE: native-tls isn't supported with `async-std`
 //!
+//! #### SMTP over TLS via the boring crate (Boring TLS)
+//!
+//! _Secure SMTP connections using TLS from the `boring-tls` crate_
+//!
+//! * **boring-tls**: TLS support for the synchronous version of the API
+//! * **tokio1-boring-tls**: TLS support for the `tokio1` async version of the API
+//!
+//! NOTE: boring-tls isn't supported with `async-std`
+//!
 //! #### SMTP over TLS via the rustls crate
 //!
 //! _Secure SMTP connections using TLS from the `rustls-tls` crate_
@@ -100,7 +109,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.10.0")]
+#![doc(html_root_url = "https://docs.rs/crate/lettre/0.10.3")]
 #![doc(html_favicon_url = "https://lettre.rs/favicon.ico")]
 #![doc(html_logo_url = "https://avatars0.githubusercontent.com/u/15113230?v=4")]
 #![forbid(unsafe_code)]
@@ -126,12 +135,18 @@
    clippy::manual_assert,
    clippy::unnecessary_join,
    clippy::wildcard_imports,
+    clippy::str_to_string,
+    clippy::empty_structs_with_brackets,
    clippy::zero_sized_map_values
 )]
 #![cfg_attr(docsrs, feature(doc_cfg))]

 #[cfg(not(lettre_ignore_tls_mismatch))]
 mod compiletime_checks {
+    #[cfg(all(feature = "native-tls", feature = "boring-tls"))]
+    compile_error!("feature \"native-tls\" and feature \"boring-tls\" cannot be enabled at the same time, otherwise
+    the executable will fail to link.");
+
    #[cfg(all(
        feature = "tokio1",
        feature = "native-tls",
@@ -150,6 +165,15 @@ mod compiletime_checks {
    If you'd like to use `native-tls` make sure that the `rustls-tls` feature hasn't been enabled by mistake.
    Make sure to apply the same to any of your crate dependencies that use the `lettre` crate.");

+    #[cfg(all(
+        feature = "tokio1",
+        feature = "boring-tls",
+        not(feature = "tokio1-boring-tls")
+    ))]
+    compile_error!("Lettre is being built with the `tokio1` and the `boring-tls` features, but the `tokio1-boring-tls` feature hasn't been turned on.
+    If you'd like to use `boring-tls` make sure that the `rustls-tls` feature hasn't been enabled by mistake.
+    Make sure to apply the same to any of your crate dependencies that use the `lettre` crate.");
+
    /*
    #[cfg(all(
        feature = "async-std1",
@@ -181,6 +205,8 @@ Make sure to apply the same to any of your crate dependencies that use the `lett
 }

 pub mod address;
+#[cfg(any(feature = "smtp-transport", feature = "dkim"))]
+mod base64;
 pub mod error;
 #[cfg(any(feature = "tokio1", feature = "async-std1"))]
 mod executor;
--- a/src/message/attachment.rs
+++ b/src/message/attachment.rs
@@ -96,7 +96,7 @@ impl Attachment {
                builder.header(header::ContentDisposition::attachment(&filename))
            }
            Disposition::Inline(content_id) => builder
-                .header(header::ContentId::from(format!("<{}>", content_id)))
+                .header(header::ContentId::from(format!("<{content_id}>")))
                .header(header::ContentDisposition::inline()),
        };
        builder = builder.header(content_type);
--- a/src/message/dkim.rs
+++ b/src/message/dkim.rs
@@ -7,9 +7,7 @@ use std::{
 };

 use ed25519_dalek::Signer;
-use once_cell::sync::Lazy;
-use regex::bytes::Regex;
-use rsa::{pkcs1::DecodeRsaPrivateKey, Hash, PaddingScheme, RsaPrivateKey};
+use rsa::{pkcs1::DecodeRsaPrivateKey, pkcs1v15::Pkcs1v15Sign, RsaPrivateKey};
 use sha2::{Digest, Sha256};

 use crate::message::{
@@ -123,14 +121,14 @@ impl DkimSigningKey {
                RsaPrivateKey::from_pkcs1_pem(private_key)
                    .map_err(|err| DkimSigningKeyError(InnerDkimSigningKeyError::Rsa(err)))?,
            ),
-            DkimSigningAlgorithm::Ed25519 => {
-                InnerDkimSigningKey::Ed25519(
-                    ed25519_dalek::Keypair::from_bytes(&base64::decode(private_key).map_err(
-                        |err| DkimSigningKeyError(InnerDkimSigningKeyError::Base64(err)),
-                    )?)
-                    .map_err(|err| DkimSigningKeyError(InnerDkimSigningKeyError::Ed25519(err)))?,
+            DkimSigningAlgorithm::Ed25519 => InnerDkimSigningKey::Ed25519(
+                ed25519_dalek::Keypair::from_bytes(
+                    &crate::base64::decode(private_key).map_err(|err| {
+                        DkimSigningKeyError(InnerDkimSigningKeyError::Base64(err))
+                    })?,
                )
-            }
+                .map_err(|err| DkimSigningKeyError(InnerDkimSigningKeyError::Ed25519(err)))?,
+            ),
        }))
    }
    fn get_signing_algorithm(&self) -> DkimSigningAlgorithm {
@@ -219,24 +217,34 @@ fn dkim_header_format(

 /// Canonicalize the body of an email
 fn dkim_canonicalize_body(
-    body: &[u8],
+    mut body: &[u8],
    canonicalization: DkimCanonicalizationType,
 ) -> Cow<'_, [u8]> {
-    static RE: Lazy<Regex> = Lazy::new(|| Regex::new("(\r\n)+$").unwrap());
-    static RE_DOUBLE_SPACE: Lazy<Regex> = Lazy::new(|| Regex::new("[\\t ]+").unwrap());
-    static RE_SPACE_EOL: Lazy<Regex> = Lazy::new(|| Regex::new("[\t ]\r\n").unwrap());
    match canonicalization {
-        DkimCanonicalizationType::Simple => RE.replace(body, &b"\r\n"[..]),
-        DkimCanonicalizationType::Relaxed => {
-            let body = RE_DOUBLE_SPACE.replace_all(body, &b" "[..]);
-            let body = match RE_SPACE_EOL.replace_all(&body, &b"\r\n"[..]) {
-                Cow::Borrowed(_body) => body,
-                Cow::Owned(body) => Cow::Owned(body),
-            };
-            match RE.replace(&body, &b"\r\n"[..]) {
-                Cow::Borrowed(_body) => body,
-                Cow::Owned(body) => Cow::Owned(body),
+        DkimCanonicalizationType::Simple => {
+            // Remove empty lines at end
+            while body.ends_with(b"\r\n\r\n") {
+                body = &body[..body.len() - 2];
            }
+            Cow::Borrowed(body)
+        }
+        DkimCanonicalizationType::Relaxed => {
+            let mut out = Vec::with_capacity(body.len());
+            loop {
+                match body {
+                    [b' ' | b'\t', b'\r', b'\n', ..] => {}
+                    [b' ' | b'\t', b' ' | b'\t', ..] => {}
+                    [b' ' | b'\t', ..] => out.push(b' '),
+                    [c, ..] => out.push(*c),
+                    [] => break,
+                }
+                body = &body[1..];
+            }
+            // Remove empty lines at end
+            while out.ends_with(b"\r\n\r\n") {
+                out.truncate(out.len() - 2);
+            }
+            Cow::Owned(out)
        }
    }
 }
@@ -346,11 +354,11 @@ fn dkim_sign_fixed_time(message: &mut Message, dkim_config: &DkimConfig, timesta
        .unwrap()
        .as_secs();
    let headers = message.headers();
-    let body_hash = Sha256::digest(&dkim_canonicalize_body(
+    let body_hash = Sha256::digest(dkim_canonicalize_body(
        &message.body_raw(),
        dkim_config.canonicalization.body,
    ));
-    let bh = base64::encode(body_hash);
+    let bh = crate::base64::encode(body_hash);
    let mut signed_headers_list =
        dkim_config
            .headers
@@ -382,16 +390,13 @@ fn dkim_sign_fixed_time(message: &mut Message, dkim_config: &DkimConfig, timesta
    hashed_headers.update(canonicalized_dkim_header.trim_end().as_bytes());
    let hashed_headers = hashed_headers.finalize();
    let signature = match &dkim_config.private_key.0 {
-        InnerDkimSigningKey::Rsa(private_key) => base64::encode(
+        InnerDkimSigningKey::Rsa(private_key) => crate::base64::encode(
            private_key
-                .sign(
-                    PaddingScheme::new_pkcs1v15_sign(Some(Hash::SHA2_256)),
-                    &hashed_headers,
-                )
+                .sign(Pkcs1v15Sign::new::<Sha256>(), &hashed_headers)
                .unwrap(),
        ),
        InnerDkimSigningKey::Ed25519(private_key) => {
-            base64::encode(private_key.sign(&hashed_headers).to_bytes())
+            crate::base64::encode(private_key.sign(&hashed_headers).to_bytes())
        }
    };
    let dkim_header = dkim_header_format(
@@ -416,8 +421,9 @@ mod test {
            header::{HeaderName, HeaderValue},
            Header, Message,
        },
-        dkim_canonicalize_headers, dkim_sign_fixed_time, DkimCanonicalization,
-        DkimCanonicalizationType, DkimConfig, DkimSigningAlgorithm, DkimSigningKey,
+        dkim_canonicalize_body, dkim_canonicalize_headers, dkim_sign_fixed_time,
+        DkimCanonicalization, DkimCanonicalizationType, DkimConfig, DkimSigningAlgorithm,
+        DkimSigningKey,
    };
    use crate::StdError;

@@ -471,9 +477,9 @@ cJ5Ku0OTwRtSMaseRPX+T4EfG1Caa/eunPPN4rh+CSup2BVVarOT
            .from("Test O'Leary <test+ezrz@example.net>".parse().unwrap())
            .to("Test2 <test2@example.org>".parse().unwrap())
            .date(std::time::UNIX_EPOCH)
-            .header(TestHeader("test  test very very long with spaces and extra spaces   \twill be folded to several lines ".to_string()))
+            .header(TestHeader("test  test very very long with spaces and extra spaces   \twill be folded to several lines ".to_owned()))
            .subject("Test with utf-8 ë")
-            .body("test\r\n\r\ntest   \ttest\r\n\r\n\r\n".to_string()).unwrap()
+            .body("test\r\n\r\ntest   \ttest\r\n\r\n\r\n".to_owned()).unwrap()
    }

    #[test]
@@ -490,6 +496,24 @@ cJ5Ku0OTwRtSMaseRPX+T4EfG1Caa/eunPPN4rh+CSup2BVVarOT
        assert_eq!(dkim_canonicalize_headers(["From", "Test"], &message.headers, DkimCanonicalizationType::Relaxed),"from:=?utf-8?b?VGVzdCBPJ0xlYXJ5?= <test+ezrz@example.net>\r\ntest:test test very very long with spaces and extra spaces will be folded to several lines\r\n")
    }

+    #[test]
+    fn test_body_simple_canonicalize() {
+        let body = b" C \r\nD \t E\r\n\r\n\r\n";
+        assert_eq!(
+            dkim_canonicalize_body(body, DkimCanonicalizationType::Simple).into_owned(),
+            b" C \r\nD \t E\r\n"
+        );
+    }
+
+    #[test]
+    fn test_body_relaxed_canonicalize() {
+        let body = b" C \r\nD \t E\r\n\tF\r\n\t\r\n\r\n\r\n";
+        assert_eq!(
+            dkim_canonicalize_body(body, DkimCanonicalizationType::Relaxed).into_owned(),
+            b" C\r\nD E\r\n F\r\n"
+        );
+    }
+
    #[test]
    fn test_signature_rsa_simple() {
        let mut message = test_message();
@@ -497,8 +521,8 @@ cJ5Ku0OTwRtSMaseRPX+T4EfG1Caa/eunPPN4rh+CSup2BVVarOT
        dkim_sign_fixed_time(
            &mut message,
            &DkimConfig::new(
-                "dkimtest".to_string(),
-                "example.org".to_string(),
+                "dkimtest".to_owned(),
+                "example.org".to_owned(),
                signing_key,
                vec![
                    HeaderName::new_from_ascii_str("Date"),
@@ -546,8 +570,8 @@ cJ5Ku0OTwRtSMaseRPX+T4EfG1Caa/eunPPN4rh+CSup2BVVarOT
        dkim_sign_fixed_time(
            &mut message,
            &DkimConfig::new(
-                "dkimtest".to_string(),
-                "example.org".to_string(),
+                "dkimtest".to_owned(),
+                "example.org".to_owned(),
                signing_key,
                vec![
                    HeaderName::new_from_ascii_str("Date"),
@@ -564,7 +588,7 @@ cJ5Ku0OTwRtSMaseRPX+T4EfG1Caa/eunPPN4rh+CSup2BVVarOT
        );
        let signed = message.formatted();
        let signed = std::str::from_utf8(&signed).unwrap();
-        println!("{}", signed);
+        println!("{signed}");
        assert_eq!(
            signed,
            std::concat!(
--- a/src/message/header/content.rs
+++ b/src/message/header/content.rs
@@ -99,7 +99,7 @@ mod test {

        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("Content-Transfer-Encoding"),
-            "7bit".to_string(),
+            "7bit".to_owned(),
        ));

        assert_eq!(
@@ -109,7 +109,7 @@ mod test {

        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("Content-Transfer-Encoding"),
-            "base64".to_string(),
+            "base64".to_owned(),
        ));

        assert_eq!(
--- a/src/message/header/content_disposition.rs
+++ b/src/message/header/content_disposition.rs
@@ -16,8 +16,8 @@ impl ContentDisposition {
    pub fn inline() -> Self {
        Self(HeaderValue::dangerous_new_pre_encoded(
            Self::name(),
-            "inline".to_string(),
-            "inline".to_string(),
+            "inline".to_owned(),
+            "inline".to_owned(),
        ))
    }

@@ -33,17 +33,19 @@ impl ContentDisposition {
    }

    fn with_name(kind: &str, file_name: &str) -> Self {
-        let raw_value = format!("{}; filename=\"{}\"", kind, file_name);
+        let raw_value = format!("{kind}; filename=\"{file_name}\"");

        let mut encoded_value = String::new();
        let line_len = "Content-Disposition: ".len();
-        let mut w = EmailWriter::new(&mut encoded_value, line_len, false);
-        w.write_str(kind).expect("writing `kind` returned an error");
-        w.write_char(';').expect("writing `;` returned an error");
-        w.space();
+        {
+            let mut w = EmailWriter::new(&mut encoded_value, line_len, 0, false, false);
+            w.write_str(kind).expect("writing `kind` returned an error");
+            w.write_char(';').expect("writing `;` returned an error");
+            w.optional_breakpoint();

-        email_encoding::headers::rfc2231::encode("filename", file_name, &mut w)
-            .expect("some Write implementation returned an error");
+            email_encoding::headers::rfc2231::encode("filename", file_name, &mut w)
+                .expect("some Write implementation returned an error");
+        }

        Self(HeaderValue::dangerous_new_pre_encoded(
            Self::name(),
@@ -88,12 +90,12 @@ mod test {

        headers.set(ContentDisposition::inline());

-        assert_eq!(format!("{}", headers), "Content-Disposition: inline\r\n");
+        assert_eq!(format!("{headers}"), "Content-Disposition: inline\r\n");

        headers.set(ContentDisposition::attachment("something.txt"));

        assert_eq!(
-            format!("{}", headers),
+            format!("{headers}"),
            "Content-Disposition: attachment; filename=\"something.txt\"\r\n"
        );
    }
@@ -104,7 +106,7 @@ mod test {

        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("Content-Disposition"),
-            "inline".to_string(),
+            "inline".to_owned(),
        ));

        assert_eq!(
@@ -114,7 +116,7 @@ mod test {

        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("Content-Disposition"),
-            "attachment; filename=\"something.txt\"".to_string(),
+            "attachment; filename=\"something.txt\"".to_owned(),
        ));

        assert_eq!(
--- a/src/message/header/content_type.rs
+++ b/src/message/header/content_type.rs
@@ -135,8 +135,7 @@ mod serde {
                    match ContentType::parse(mime) {
                        Ok(content_type) => Ok(content_type),
                        Err(_) => Err(E::custom(format!(
-                            "Couldn't parse the following MIME-Type: {}",
-                            mime
+                            "Couldn't parse the following MIME-Type: {mime}"
                        ))),
                    }
                }
@@ -179,14 +178,14 @@ mod test {

        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("Content-Type"),
-            "text/plain; charset=utf-8".to_string(),
+            "text/plain; charset=utf-8".to_owned(),
        ));

        assert_eq!(headers.get::<ContentType>(), Some(ContentType::TEXT_PLAIN));

        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("Content-Type"),
-            "text/html; charset=utf-8".to_string(),
+            "text/html; charset=utf-8".to_owned(),
        ));

        assert_eq!(headers.get::<ContentType>(), Some(ContentType::TEXT_HTML));
--- a/src/message/header/date.rs
+++ b/src/message/header/date.rs
@@ -90,7 +90,7 @@ mod test {

        assert_eq!(
            headers.to_string(),
-            "Date: Tue, 15 Nov 1994 08:12:31 +0000\r\n".to_string()
+            "Date: Tue, 15 Nov 1994 08:12:31 +0000\r\n".to_owned()
        );

        // Tue, 15 Nov 1994 08:12:32 GMT
@@ -110,7 +110,7 @@ mod test {

        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("Date"),
-            "Tue, 15 Nov 1994 08:12:31 +0000".to_string(),
+            "Tue, 15 Nov 1994 08:12:31 +0000".to_owned(),
        ));

        assert_eq!(
@@ -122,7 +122,7 @@ mod test {

        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("Date"),
-            "Tue, 15 Nov 1994 08:12:32 +0000".to_string(),
+            "Tue, 15 Nov 1994 08:12:32 +0000".to_owned(),
        ));

        assert_eq!(
--- a/src/message/header/mailbox.rs
+++ b/src/message/header/mailbox.rs
@@ -30,8 +30,10 @@ macro_rules! mailbox_header {
            fn display(&self) -> HeaderValue {
                let mut encoded_value = String::new();
                let line_len = $header_name.len() + ": ".len();
-                let mut w = EmailWriter::new(&mut encoded_value, line_len, false);
-                self.0.encode(&mut w).expect("writing `Mailbox` returned an error");
+                {
+                    let mut w = EmailWriter::new(&mut encoded_value, line_len, 0, false, false);
+                    self.0.encode(&mut w).expect("writing `Mailbox` returned an error");
+                }

                HeaderValue::dangerous_new_pre_encoded(Self::name(), self.0.to_string(), encoded_value)
            }
@@ -78,8 +80,10 @@ macro_rules! mailboxes_header {
            fn display(&self) -> HeaderValue {
                let mut encoded_value = String::new();
                let line_len = $header_name.len() + ": ".len();
-                let mut w = EmailWriter::new(&mut encoded_value, line_len, false);
-                self.0.encode(&mut w).expect("writing `Mailboxes` returned an error");
+                {
+                    let mut w = EmailWriter::new(&mut encoded_value, line_len, 0, false, false);
+                    self.0.encode(&mut w).expect("writing `Mailboxes` returned an error");
+                }

                HeaderValue::dangerous_new_pre_encoded(Self::name(), self.0.to_string(), encoded_value)
            }
@@ -248,7 +252,7 @@ mod test {
        let mut headers = Headers::new();
        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("From"),
-            "kayo@example.com".to_string(),
+            "kayo@example.com".to_owned(),
        ));

        assert_eq!(headers.get::<From>(), Some(From(from)));
@@ -261,7 +265,7 @@ mod test {
        let mut headers = Headers::new();
        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("From"),
-            "K. <kayo@example.com>".to_string(),
+            "K. <kayo@example.com>".to_owned(),
        ));

        assert_eq!(headers.get::<From>(), Some(From(from)));
@@ -277,7 +281,7 @@ mod test {
        let mut headers = Headers::new();
        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("From"),
-            "kayo@example.com, pony@domain.tld".to_string(),
+            "kayo@example.com, pony@domain.tld".to_owned(),
        ));

        assert_eq!(headers.get::<From>(), Some(From(from.into())));
@@ -293,7 +297,7 @@ mod test {
        let mut headers = Headers::new();
        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("From"),
-            "K. <kayo@example.com>, Pony P. <pony@domain.tld>".to_string(),
+            "K. <kayo@example.com>, Pony P. <pony@domain.tld>".to_owned(),
        ));

        assert_eq!(headers.get::<From>(), Some(From(from.into())));
@@ -309,7 +313,7 @@ mod test {
        let mut headers = Headers::new();
        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("From"),
-            "Test, test <1@example.com>, Test2, test2 <2@example.com>".to_string(),
+            "Test, test <1@example.com>, Test2, test2 <2@example.com>".to_owned(),
        ));

        assert_eq!(headers.get::<From>(), Some(From(from.into())));
@@ -320,7 +324,7 @@ mod test {
        let mut headers = Headers::new();
        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("From"),
-            "Test, test <1@example.com>, Test2, test2".to_string(),
+            "Test, test <1@example.com>, Test2, test2".to_owned(),
        ));

        assert_eq!(headers.get::<From>(), None);
--- a/src/message/header/mod.rs
+++ b/src/message/header/mod.rs
@@ -323,10 +323,12 @@ impl HeaderValue {
        }
    }

+    #[cfg(feature = "dkim")]
    pub(crate) fn get_raw(&self) -> &str {
        &self.raw_value
    }

+    #[cfg(feature = "dkim")]
    pub(crate) fn get_encoded(&self) -> &str {
        &self.encoded_value
    }
@@ -340,28 +342,21 @@ struct HeaderValueEncoder<'a> {

 impl<'a> HeaderValueEncoder<'a> {
    fn encode(name: &str, value: &'a str, f: &'a mut impl fmt::Write) -> fmt::Result {
-        let (words_iter, encoder) = Self::new(name, value, f);
-        encoder.format(words_iter)
+        let encoder = Self::new(name, f);
+        encoder.format(value.split_inclusive(' '))
    }

-    fn new(
-        name: &str,
-        value: &'a str,
-        writer: &'a mut dyn Write,
-    ) -> (WordsPlusFillIterator<'a>, Self) {
+    fn new(name: &str, writer: &'a mut dyn Write) -> Self {
        let line_len = name.len() + ": ".len();
-        let writer = EmailWriter::new(writer, line_len, false);
+        let writer = EmailWriter::new(writer, line_len, 0, false, false);

-        (
-            WordsPlusFillIterator { s: value },
-            Self {
-                writer,
-                encode_buf: String::new(),
-            },
-        )
+        Self {
+            writer,
+            encode_buf: String::new(),
+        }
    }

-    fn format(mut self, words_iter: WordsPlusFillIterator<'_>) -> fmt::Result {
+    fn format(mut self, words_iter: impl Iterator<Item = &'a str>) -> fmt::Result {
        for next_word in words_iter {
            let allowed = allowed_str(next_word);

@@ -389,71 +384,20 @@ impl<'a> HeaderValueEncoder<'a> {
            return Ok(());
        }

-        // It is important that we don't encode leading whitespace otherwise it breaks wrapping.
-        let first_not_allowed = self
-            .encode_buf
-            .bytes()
-            .enumerate()
-            .find(|(_i, c)| !allowed_char(*c))
-            .map(|(i, _)| i);
-        // May as well also write the tail in plain text.
-        let last_not_allowed = self
-            .encode_buf
-            .bytes()
-            .enumerate()
-            .rev()
-            .find(|(_i, c)| !allowed_char(*c))
-            .map(|(i, _)| i + 1);
+        let prefix = self.encode_buf.trim_end_matches(' ');
+        email_encoding::headers::rfc2047::encode(prefix, &mut self.writer)?;

-        let (prefix, to_encode, suffix) = match first_not_allowed {
-            Some(first_not_allowed) => {
-                let last_not_allowed = last_not_allowed.unwrap();
-
-                let (remaining, suffix) = self.encode_buf.split_at(last_not_allowed);
-                let (prefix, to_encode) = remaining.split_at(first_not_allowed);
-
-                (prefix, to_encode, suffix)
-            }
-            None => ("", self.encode_buf.as_str(), ""),
-        };
-
-        self.writer.folding().write_str(prefix)?;
-        email_encoding::headers::rfc2047::encode(to_encode, &mut self.writer)?;
-        self.writer.folding().write_str(suffix)?;
+        // TODO: add a better API for doing this in email-encoding
+        let spaces = self.encode_buf.len() - prefix.len();
+        for _ in 0..spaces {
+            self.writer.space();
+        }

        self.encode_buf.clear();
        Ok(())
    }
 }

-/// Iterator yielding a string split by space, but spaces are included before the next word.
-struct WordsPlusFillIterator<'a> {
-    s: &'a str,
-}
-
-impl<'a> Iterator for WordsPlusFillIterator<'a> {
-    type Item = &'a str;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.s.is_empty() {
-            return None;
-        }
-
-        let next_word = self
-            .s
-            .bytes()
-            .enumerate()
-            .skip(1)
-            .find(|&(_i, c)| c == b' ')
-            .map(|(i, _)| i)
-            .unwrap_or(self.s.len());
-
-        let word = &self.s[..next_word];
-        self.s = &self.s[word.len()..];
-        Some(word)
-    }
-}
-
 fn allowed_str(s: &str) -> bool {
    s.bytes().all(allowed_char)
 }
@@ -466,7 +410,8 @@ const fn allowed_char(c: u8) -> bool {
 mod tests {
    use pretty_assertions::assert_eq;

-    use super::{HeaderName, HeaderValue, Headers};
+    use super::{HeaderName, HeaderValue, Headers, To};
+    use crate::message::Mailboxes;

    #[test]
    fn valid_headername() {
@@ -529,7 +474,7 @@ mod tests {
        let mut headers = Headers::new();
        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("To"),
-            "John Doe <example@example.com>, Jean Dupont <jean@example.com>".to_string(),
+            "John Doe <example@example.com>, Jean Dupont <jean@example.com>".to_owned(),
        ));

        assert_eq!(
@@ -543,7 +488,7 @@ mod tests {
        let mut headers = Headers::new();
        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("To"),
-            "Ascii <example@example.com>, John Doe <johndoe@example.com, John Smith <johnsmith@example.com>, Pinco Pallino <pincopallino@example.com>, Jemand <jemand@example.com>, Jean Dupont <jean@example.com>".to_string(),
+            "Ascii <example@example.com>, John Doe <johndoe@example.com, John Smith <johnsmith@example.com>, Pinco Pallino <pincopallino@example.com>, Jemand <jemand@example.com>, Jean Dupont <jean@example.com>".to_owned(),
        ));

        assert_eq!(
@@ -561,7 +506,7 @@ mod tests {
        let mut headers = Headers::new();
        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("Subject"),
-            "Hello! This is lettre, and this IsAVeryLongLineDoYouKnowWhatsGoingToHappenIGuessWeAreGoingToFindOut. Ok I guess that's it!".to_string()
+            "Hello! This is lettre, and this IsAVeryLongLineDoYouKnowWhatsGoingToHappenIGuessWeAreGoingToFindOut. Ok I guess that's it!".to_owned()
        ));

        assert_eq!(
@@ -580,7 +525,7 @@ mod tests {
        headers.insert_raw(
            HeaderValue::new(
            HeaderName::new_from_ascii_str("Subject"),
-            "Hello! IGuessTheLastLineWasntLongEnoughSoLetsTryAgainShallWeWhatDoYouThinkItsGoingToHappenIGuessWereAboutToFindOut! I don't know".to_string()
+            "Hello! IGuessTheLastLineWasntLongEnoughSoLetsTryAgainShallWeWhatDoYouThinkItsGoingToHappenIGuessWereAboutToFindOut! I don't know".to_owned()
        ));

        assert_eq!(
@@ -598,7 +543,7 @@ mod tests {
        let mut headers = Headers::new();
        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("Subject"),
-            "1abcdefghijklmnopqrstuvwxyz2abcdefghijklmnopqrstuvwxyz3abcdefghijklmnopqrstuvwxyz4abcdefghijklmnopqrstuvwxyz5abcdefghijklmnopqrstuvwxyz6abcdefghijklmnopqrstuvwxyz".to_string()
+            "1abcdefghijklmnopqrstuvwxyz2abcdefghijklmnopqrstuvwxyz3abcdefghijklmnopqrstuvwxyz4abcdefghijklmnopqrstuvwxyz5abcdefghijklmnopqrstuvwxyz6abcdefghijklmnopqrstuvwxyz".to_owned()
        ));

        assert_eq!(
@@ -612,12 +557,12 @@ mod tests {
        let mut headers = Headers::new();
        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("To"),
-            "Seán <sean@example.com>".to_string(),
+            "Seán <sean@example.com>".to_owned(),
        ));

        assert_eq!(
            headers.to_string(),
-            "To: Se=?utf-8?b?w6E=?=n <sean@example.com>\r\n"
+            "To: =?utf-8?b?U2XDoW4=?= <sean@example.com>\r\n"
        );
    }

@@ -626,7 +571,7 @@ mod tests {
        let mut headers = Headers::new();
        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("To"),
-            "🌎 <world@example.com>".to_string(),
+            "🌎 <world@example.com>".to_owned(),
        ));

        assert_eq!(
@@ -638,19 +583,46 @@ mod tests {
    #[test]
    fn format_special_with_folding() {
        let mut headers = Headers::new();
-        headers.insert_raw(HeaderValue::new(
-            HeaderName::new_from_ascii_str("To"),
-            "🌍 <world@example.com>, 🦆 Everywhere <ducks@example.com>, Иванов Иван Иванович <ivanov@example.com>, Jānis Bērziņš <janis@example.com>, Seán Ó Rudaí <sean@example.com>".to_string(),
-         ) );
+        let to = To::from(Mailboxes::from_iter([
+            "🌍 <world@example.com>".parse().unwrap(),
+            "🦆 Everywhere <ducks@example.com>".parse().unwrap(),
+            "Иванов Иван Иванович <ivanov@example.com>".parse().unwrap(),
+            "Jānis Bērziņš <janis@example.com>".parse().unwrap(),
+            "Seán Ó Rudaí <sean@example.com>".parse().unwrap(),
+        ]));
+        headers.set(to);

        assert_eq!(
            headers.to_string(),
            concat!(
-                "To: =?utf-8?b?8J+MjQ==?= <world@example.com>, =?utf-8?b?8J+mhg==?= Everywhere\r\n",
-                " <ducks@example.com>, =?utf-8?b?0JjQstCw0L3QvtCyINCY0LLQsNC9INCY0LLQsNC9?=\r\n",
-                " =?utf-8?b?0L7QstC40Yc=?= <ivanov@example.com>, J=?utf-8?b?xIFuaXMgQsST?=\r\n",
-                " =?utf-8?b?cnppxYbFoQ==?= <janis@example.com>, Se=?utf-8?b?w6FuIMOTIFJ1?=\r\n",
-                " =?utf-8?b?ZGHDrQ==?= <sean@example.com>\r\n",
+                "To: =?utf-8?b?8J+MjQ==?= <world@example.com>, =?utf-8?b?8J+mhiBFdmVyeXdo?=\r\n",
+                " =?utf-8?b?ZXJl?= <ducks@example.com>, =?utf-8?b?0JjQstCw0L3QvtCyINCY0LI=?=\r\n",
+                " =?utf-8?b?0LDQvSDQmNCy0LDQvdC+0LLQuNGH?= <ivanov@example.com>,\r\n",
+                " =?utf-8?b?SsSBbmlzIELEk3J6acWGxaE=?= <janis@example.com>, =?utf-8?b?U2U=?=\r\n",
+                " =?utf-8?b?w6FuIMOTIFJ1ZGHDrQ==?= <sean@example.com>\r\n",
+            )
+        );
+    }
+
+    #[test]
+    fn format_special_with_folding_raw() {
+        let mut headers = Headers::new();
+        headers.insert_raw(HeaderValue::new(
+            HeaderName::new_from_ascii_str("To"),
+            "🌍 <world@example.com>, 🦆 Everywhere <ducks@example.com>, Иванов Иван Иванович <ivanov@example.com>, Jānis Bērziņš <janis@example.com>, Seán Ó Rudaí <sean@example.com>".to_owned(),
+        ));
+
+        // 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?U2XDoW4gw5MgUnVkYcOt?= <sean@example.com>\r\n",
            )
        );
    }
@@ -661,7 +633,7 @@ mod tests {
        headers.insert_raw(
            HeaderValue::new(
            HeaderName::new_from_ascii_str("Subject"),
-            "🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳".to_string(),)
+            "🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳".to_owned(),)
        );

        assert_eq!(
@@ -682,7 +654,7 @@ mod tests {
        let mut headers = Headers::new();
        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("Subject"),
-            "Hello! \r\n This is \" bad \0. 👋".to_string(),
+            "Hello! \r\n This is \" bad \0. 👋".to_owned(),
        ));

        assert_eq!(
@@ -697,35 +669,38 @@ mod tests {
        headers.insert_raw(
            HeaderValue::new(
            HeaderName::new_from_ascii_str("Subject"),
-            "Hello! This is lettre, and this IsAVeryLongLineDoYouKnowWhatsGoingToHappenIGuessWeAreGoingToFindOut. Ok I guess that's it!".to_string()
+            "Hello! This is lettre, and this IsAVeryLongLineDoYouKnowWhatsGoingToHappenIGuessWeAreGoingToFindOut. Ok I guess that's it!".to_owned()
            )
        );
        headers.insert_raw(
            HeaderValue::new(
            HeaderName::new_from_ascii_str("To"),
-            "🌍 <world@example.com>, 🦆 Everywhere <ducks@example.com>, Иванов Иван Иванович <ivanov@example.com>, Jānis Bērziņš <janis@example.com>, Seán Ó Rudaí <sean@example.com>".to_string(),
+            "🌍 <world@example.com>, 🦆 Everywhere <ducks@example.com>, Иванов Иван Иванович <ivanov@example.com>, Jānis Bērziņš <janis@example.com>, Seán Ó Rudaí <sean@example.com>".to_owned(),
            )
        );
        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("From"),
-            "Someone <somewhere@example.com>".to_string(),
+            "Someone <somewhere@example.com>".to_owned(),
        ));
        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("Content-Transfer-Encoding"),
-            "quoted-printable".to_string(),
+            "quoted-printable".to_owned(),
        ));

+        // 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!(
                "Subject: Hello! This is lettre, and this\r\n",
                " IsAVeryLongLineDoYouKnowWhatsGoingToHappenIGuessWeAreGoingToFindOut. Ok I\r\n",
                " guess that's it!\r\n",
-                "To: =?utf-8?b?8J+MjQ==?= <world@example.com>, =?utf-8?b?8J+mhg==?= Everywhere\r\n",
-                " <ducks@example.com>, =?utf-8?b?0JjQstCw0L3QvtCyINCY0LLQsNC9INCY0LLQsNC9?=\r\n",
-                " =?utf-8?b?0L7QstC40Yc=?= <ivanov@example.com>, J=?utf-8?b?xIFuaXMgQsST?=\r\n",
-                " =?utf-8?b?cnppxYbFoQ==?= <janis@example.com>, Se=?utf-8?b?w6FuIMOTIFJ1?=\r\n",
-                " =?utf-8?b?ZGHDrQ==?= <sean@example.com>\r\n",
+                "To: =?utf-8?b?8J+MjQ==?= <world@example.com>, =?utf-8?b?8J+mhg==?=\r\n",
+                " Everywhere <ducks@example.com>, =?utf-8?b?0JjQstCw0L3QvtCyINCY0LLQsNC9?=\r\n",
+                " =?utf-8?b?INCY0LLQsNC90L7QstC40Yc=?= <ivanov@example.com>,\r\n",
+                "  =?utf-8?b?SsSBbmlzIELEk3J6acWGxaE=?= <janis@example.com>,\r\n",
+                "  =?utf-8?b?U2XDoW4gw5MgUnVkYcOt?= <sean@example.com>\r\n",
                "From: Someone <somewhere@example.com>\r\n",
                "Content-Transfer-Encoding: quoted-printable\r\n",
            )
@@ -737,14 +712,14 @@ mod tests {
        let mut headers = Headers::new();
        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("Subject"),
-            "＋仮名 :a;go; ;;;;;s;;;;;;;;;;;;;;;;fffeinmjgggggggggｆっ".to_string(),
+            "＋仮名 :a;go; ;;;;;s;;;;;;;;;;;;;;;;fffeinmjgggggggggｆっ".to_owned(),
        ));

        assert_eq!(
            headers.to_string(),
            concat!(
-                "Subject: =?utf-8?b?77yL5Luu5ZCN?= :a;go;\r\n",
-                " ;;;;;s;;;;;;;;;;;;;;;;fffeinmjggggggggg=?utf-8?b?772G44Gj?=\r\n"
+                "Subject: =?utf-8?b?77yL5Luu5ZCN?= :a;go; =?utf-8?b?Ozs7OztzOzs7Ozs7Ozs7?=\r\n",
+                " =?utf-8?b?Ozs7Ozs7O2ZmZmVpbm1qZ2dnZ2dnZ2dn772G44Gj?=\r\n",
            )
        );
    }
--- a/src/message/header/special.rs
+++ b/src/message/header/special.rs
@@ -91,14 +91,14 @@ mod test {

        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("MIME-Version"),
-            "1.0".to_string(),
+            "1.0".to_owned(),
        ));

        assert_eq!(headers.get::<MimeVersion>(), Some(MIME_VERSION_1_0));

        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("MIME-Version"),
-            "0.1".to_string(),
+            "0.1".to_owned(),
        ));

        assert_eq!(headers.get::<MimeVersion>(), Some(MimeVersion::new(0, 1)));
--- a/src/message/header/textual.rs
+++ b/src/message/header/textual.rs
@@ -109,12 +109,23 @@ mod test {
        );
    }

+    #[test]
+    fn format_utf8_word() {
+        let mut headers = Headers::new();
+        headers.set(Subject("Administratör".into()));
+
+        assert_eq!(
+            headers.to_string(),
+            "Subject: =?utf-8?b?QWRtaW5pc3RyYXTDtnI=?=\r\n"
+        );
+    }
+
    #[test]
    fn parse_ascii() {
        let mut headers = Headers::new();
        headers.insert_raw(HeaderValue::new(
            HeaderName::new_from_ascii_str("Subject"),
-            "Sample subject".to_string(),
+            "Sample subject".to_owned(),
        ));

        assert_eq!(
--- a/src/message/mailbox/serde.rs
+++ b/src/message/mailbox/serde.rs
@@ -13,7 +13,7 @@ impl Serialize for Mailbox {
    where
        S: Serializer,
    {
-        serializer.serialize_str(&self.to_string())
+        serializer.collect_str(self)
    }
 }

@@ -111,7 +111,7 @@ impl Serialize for Mailboxes {
    where
        S: Serializer,
    {
-        serializer.serialize_str(&self.to_string())
+        serializer.collect_str(self)
    }
 }

--- a/src/message/mailbox/types.rs
+++ b/src/message/mailbox/types.rs
@@ -70,7 +70,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.space();
+            w.optional_breakpoint();
            w.write_char('<')?;
        }

@@ -275,7 +275,7 @@ impl Mailboxes {
        for mailbox in self.iter() {
            if !mem::take(&mut first) {
                w.write_char(',')?;
-                w.space();
+                w.optional_breakpoint();
            }

            mailbox.encode(w)?;
@@ -397,7 +397,7 @@ fn write_word(f: &mut Formatter<'_>, s: &str) -> FmtResult {
    } else {
        // Quoted string: https://datatracker.ietf.org/doc/html/rfc2822#section-3.2.5
        f.write_char('"')?;
-        for &c in s.as_bytes() {
+        for c in s.chars() {
            write_quoted_string_char(f, c)?;
        }
        f.write_char('"')?;
@@ -441,34 +441,37 @@ fn is_valid_atom_char(c: u8) -> bool {
 }

 // https://datatracker.ietf.org/doc/html/rfc2822#section-3.2.5
-fn write_quoted_string_char(f: &mut Formatter<'_>, c: u8) -> FmtResult {
+fn write_quoted_string_char(f: &mut Formatter<'_>, c: char) -> FmtResult {
    match c {
-		// NO-WS-CTL: https://datatracker.ietf.org/doc/html/rfc2822#section-3.2.1
-		1..=8 | 11 | 12 | 14..=31 | 127 |
+        // Can not be encoded.
+        '\n' | '\r' => Err(std::fmt::Error),

-		// Note, not qcontent but can be put before or after any qcontent.
-		b'\t' |
-		b' ' |
+        // Note, not qcontent but can be put before or after any qcontent.
+        '\t' | ' ' => f.write_char(c),

-		// The rest of the US-ASCII except \ and "
-		33 |
-		35..=91 |
-		93..=126 |
+        c if match c as u32 {
+            // NO-WS-CTL: https://datatracker.ietf.org/doc/html/rfc2822#section-3.2.1
+            1..=8 | 11 | 12 | 14..=31 | 127 |

-		// Non-ascii characters will be escaped separately later.
-		128..=255
+            // The rest of the US-ASCII except \ and "
+            33 |
+            35..=91 |
+            93..=126 |

-		=> f.write_char(c.into()),
+            // Non-ascii characters will be escaped separately later.
+            128.. => true,
+            _ => false,
+        } =>
+        {
+            f.write_char(c)
+        }

-		// Can not be encoded.
-		b'\n' | b'\r' => Err(std::fmt::Error),
-
-		c => {
-			// quoted-pair https://datatracker.ietf.org/doc/html/rfc2822#section-3.2.2
-			f.write_char('\\')?;
-			f.write_char(c.into())
-		}
-	}
+        _ => {
+            // quoted-pair https://datatracker.ietf.org/doc/html/rfc2822#section-3.2.2
+            f.write_char('\\')?;
+            f.write_char(c)
+        }
+    }
 }

 #[cfg(test)]
@@ -515,6 +518,34 @@ mod test {
        );
    }

+    #[test]
+    fn mailbox_format_address_with_comma_and_non_ascii() {
+        assert_eq!(
+            format!(
+                "{}",
+                Mailbox::new(
+                    Some("Laşt, First".into()),
+                    "kayo@example.com".parse().unwrap()
+                )
+            ),
+            r#""Laşt, First" <kayo@example.com>"#
+        );
+    }
+
+    #[test]
+    fn mailbox_format_address_with_comma_and_quoted_non_ascii() {
+        assert_eq!(
+            format!(
+                "{}",
+                Mailbox::new(
+                    Some(r#"Laşt, "First""#.into()),
+                    "kayo@example.com".parse().unwrap()
+                )
+            ),
+            r#""Laşt, \"First\"" <kayo@example.com>"#
+        );
+    }
+
    #[test]
    fn mailbox_format_address_with_color() {
        assert_eq!(
@@ -589,7 +620,7 @@ mod test {
    #[test]
    fn parse_address_from_tuple() {
        assert_eq!(
-            ("K.".to_string(), "kayo@example.com".to_string()).try_into(),
+            ("K.".to_owned(), "kayo@example.com".to_owned()).try_into(),
            Ok(Mailbox::new(
                Some("K.".into()),
                "kayo@example.com".parse().unwrap()
--- a/src/message/mimebody.rs
+++ b/src/message/mimebody.rs
@@ -190,9 +190,9 @@ impl MultiPartKind {
            },
            boundary,
            match self {
-                Self::Encrypted { protocol } => format!("; protocol=\"{}\"", protocol),
+                Self::Encrypted { protocol } => format!("; protocol=\"{protocol}\""),
                Self::Signed { protocol, micalg } =>
-                    format!("; protocol=\"{}\"; micalg=\"{}\"", protocol, micalg),
+                    format!("; protocol=\"{protocol}\"; micalg=\"{micalg}\""),
                _ => String::new(),
            }
        )
--- a/src/message/mod.rs
+++ b/src/message/mod.rs
@@ -14,7 +14,7 @@
 //! The easiest way of creating a message, which uses a plain text body.
 //!
 //! ```rust
-//! use lettre::message::Message;
+//! use lettre::message::{header::ContentType, Message};
 //!
 //! # use std::error::Error;
 //! # fn main() -> Result<(), Box<dyn Error>> {
@@ -23,6 +23,7 @@
 //!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
 //!     .to("Hei <hei@domain.tld>".parse()?)
 //!     .subject("Happy new year")
+//!     .header(ContentType::TEXT_PLAIN)
 //!     .body(String::from("Be happy!"))?;
 //! # Ok(())
 //! # }
@@ -38,6 +39,7 @@
 //! To: Hei <hei@domain.tld>
 //! Subject: Happy new year
 //! Date: Sat, 12 Dec 2020 16:33:19 GMT
+//! Content-Type: text/plain; charset=utf-8
 //! Content-Transfer-Encoding: 7bit
 //!
 //! Be happy!
@@ -343,9 +345,9 @@ impl MessageBuilder {
                let hostname = hostname::get()
                    .map_err(|_| ())
                    .and_then(|s| s.into_string().map_err(|_| ()))
-                    .unwrap_or_else(|_| DEFAULT_MESSAGE_ID_DOMAIN.to_string());
+                    .unwrap_or_else(|_| DEFAULT_MESSAGE_ID_DOMAIN.to_owned());
                #[cfg(not(feature = "hostname"))]
-                let hostname = DEFAULT_MESSAGE_ID_DOMAIN.to_string();
+                let hostname = DEFAULT_MESSAGE_ID_DOMAIN.to_owned();

                self.header(header::MessageId::from(
                    // https://tools.ietf.org/html/rfc5322#section-3.6.4
@@ -356,7 +358,7 @@ impl MessageBuilder {
    }

    /// Set [User-Agent
-    /// header](https://tools.ietf.org/html/draft-melnikov-email-user-agent-004)
+    /// header](https://tools.ietf.org/html/draft-melnikov-email-user-agent-00)
    pub fn user_agent(self, id: String) -> Self {
        self.header(header::UserAgent::from(id))
    }
@@ -539,7 +541,7 @@ impl Message {
    ///     .reply_to("Bob <bob@example.org>".parse().unwrap())
    ///     .to("Carla <carla@example.net>".parse().unwrap())
    ///     .subject("Hello")
-    ///     .body("Hi there, it's a test email, with utf-8 chars ë!\n\n\n".to_string())
+    ///     .body("Hi there, it's a test email, with utf-8 chars ë!\n\n\n".to_owned())
    ///     .unwrap();
    /// let key = "-----BEGIN RSA PRIVATE KEY-----
    /// MIIEowIBAAKCAQEAt2gawjoybf0mAz0mSX0cq1ah5F9cPazZdCwLnFBhRufxaZB8
@@ -570,8 +572,8 @@ impl Message {
    /// -----END RSA PRIVATE KEY-----";
    /// let signing_key = DkimSigningKey::new(key, DkimSigningAlgorithm::Rsa).unwrap();
    /// message.sign(&DkimConfig::default_config(
-    ///     "dkimtest".to_string(),
-    ///     "example.org".to_string(),
+    ///     "dkimtest".to_owned(),
+    ///     "example.org".to_owned(),
    ///     signing_key,
    /// ));
    /// println!(
@@ -673,7 +675,7 @@ mod test {
                "Date: Tue, 15 Nov 1994 08:12:31 +0000\r\n",
                "From: =?utf-8?b?0JrQsNC4?= <kayo@example.com>\r\n",
                "To: \"Pony O.P.\" <pony@domain.tld>\r\n",
-                "Subject: =?utf-8?b?0Y/So9CwINC10Lsg0LHQtdC705nQvQ==?=!\r\n",
+                "Subject: =?utf-8?b?0Y/So9CwINC10Lsg0LHQtdC705nQvSE=?=\r\n",
                "Content-Transfer-Encoding: 7bit\r\n",
                "\r\n",
                "Happy new year!"
@@ -711,7 +713,7 @@ mod test {
                "Bcc: hidden@example.com\r\n",
                "From: =?utf-8?b?0JrQsNC4?= <kayo@example.com>\r\n",
                "To: \"Pony O.P.\" <pony@domain.tld>\r\n",
-                "Subject: =?utf-8?b?0Y/So9CwINC10Lsg0LHQtdC705nQvQ==?=!\r\n",
+                "Subject: =?utf-8?b?0Y/So9CwINC10Lsg0LHQtdC705nQvSE=?=\r\n",
                "Content-Transfer-Encoding: 7bit\r\n",
                "\r\n",
                "Happy new year!"
--- a/src/transport/file/error.rs
+++ b/src/transport/file/error.rs
@@ -71,7 +71,7 @@ impl fmt::Display for Error {
        };

        if let Some(ref e) = self.inner.source {
-            write!(f, ": {}", e)?;
+            write!(f, ": {e}")?;
        }

        Ok(())
--- a/src/transport/file/mod.rs
+++ b/src/transport/file/mod.rs
@@ -208,18 +208,18 @@ impl FileTransport {
    pub fn read(&self, email_id: &str) -> Result<(Envelope, Vec<u8>), Error> {
        use std::fs;

-        let eml_file = self.path.join(format!("{}.eml", email_id));
+        let eml_file = self.path.join(format!("{email_id}.eml"));
        let eml = fs::read(eml_file).map_err(error::io)?;

-        let json_file = self.path.join(format!("{}.json", email_id));
-        let json = fs::read(&json_file).map_err(error::io)?;
+        let json_file = self.path.join(format!("{email_id}.json"));
+        let json = fs::read(json_file).map_err(error::io)?;
        let envelope = serde_json::from_slice(&json).map_err(error::envelope)?;

        Ok((envelope, eml))
    }

    fn path(&self, email_id: &Uuid, extension: &str) -> PathBuf {
-        self.path.join(format!("{}.{}", email_id, extension))
+        self.path.join(format!("{email_id}.{extension}"))
    }
 }

@@ -255,10 +255,10 @@ where
    /// Reads the envelope and the raw message content.
    #[cfg(feature = "file-transport-envelope")]
    pub async fn read(&self, email_id: &str) -> Result<(Envelope, Vec<u8>), Error> {
-        let eml_file = self.inner.path.join(format!("{}.eml", email_id));
+        let eml_file = self.inner.path.join(format!("{email_id}.eml"));
        let eml = E::fs_read(&eml_file).await.map_err(error::io)?;

-        let json_file = self.inner.path.join(format!("{}.json", email_id));
+        let json_file = self.inner.path.join(format!("{email_id}.json"));
        let json = E::fs_read(&json_file).await.map_err(error::io)?;
        let envelope = serde_json::from_slice(&json).map_err(error::envelope)?;

@@ -276,6 +276,8 @@ impl Transport for FileTransport {
        let email_id = Uuid::new_v4();

        let file = self.path(&email_id, "eml");
+        #[cfg(feature = "tracing")]
+        tracing::debug!(?file, "writing email to");
        fs::write(file, email).map_err(error::io)?;

        #[cfg(feature = "file-transport-envelope")]
@@ -306,6 +308,8 @@ where
        let email_id = Uuid::new_v4();

        let file = self.inner.path(&email_id, "eml");
+        #[cfg(feature = "tracing")]
+        tracing::debug!(?file, "writing email to");
        E::fs_write(&file, email).await.map_err(error::io)?;

        #[cfg(feature = "file-transport-envelope")]
--- a/src/transport/mod.rs
+++ b/src/transport/mod.rs
@@ -65,7 +65,7 @@
 //!     .subject("Happy new year")
 //!     .body(String::from("Be happy!"))?;
 //!
-//! let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
+//! let creds = Credentials::new("smtp_username".to_owned(), "smtp_password".to_owned());
 //!
 //! // Open a remote connection to the SMTP relay server
 //! let mailer = SmtpTransport::relay("smtp.gmail.com")?
@@ -127,6 +127,9 @@ pub trait Transport {
    #[cfg(feature = "builder")]
    #[cfg_attr(docsrs, doc(cfg(feature = "builder")))]
    fn send(&self, message: &Message) -> Result<Self::Ok, Self::Error> {
+        #[cfg(feature = "tracing")]
+        tracing::trace!("starting to send an email");
+
        let raw = message.formatted();
        self.send_raw(message.envelope(), &raw)
    }
@@ -149,6 +152,9 @@ pub trait AsyncTransport {
    #[cfg_attr(docsrs, doc(cfg(feature = "builder")))]
    // TODO take &Message
    async fn send(&self, message: Message) -> Result<Self::Ok, Self::Error> {
+        #[cfg(feature = "tracing")]
+        tracing::trace!("starting to send an email");
+
        let raw = message.formatted();
        let envelope = message.envelope();
        self.send_raw(envelope, &raw).await
--- a/src/transport/sendmail/error.rs
+++ b/src/transport/sendmail/error.rs
@@ -68,7 +68,7 @@ impl fmt::Display for Error {
        };

        if let Some(ref e) = self.inner.source {
-            write!(f, ": {}", e)?;
+            write!(f, ": {e}")?;
        }

        Ok(())
--- a/src/transport/sendmail/mod.rs
+++ b/src/transport/sendmail/mod.rs
@@ -232,6 +232,9 @@ impl Transport for SendmailTransport {
    type Error = Error;

    fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
+        #[cfg(feature = "tracing")]
+        tracing::debug!(command = ?self.command, "sending email with");
+
        // Spawn the sendmail command
        let mut process = self.command(envelope).spawn().map_err(error::client)?;

@@ -261,6 +264,9 @@ impl AsyncTransport for AsyncSendmailTransport<AsyncStd1Executor> {
    async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
        use async_std::io::prelude::WriteExt;

+        #[cfg(feature = "tracing")]
+        tracing::debug!(command = ?self.inner.command, "sending email with");
+
        let mut command = self.async_std_command(envelope);

        // Spawn the sendmail command
@@ -293,6 +299,9 @@ impl AsyncTransport for AsyncSendmailTransport<Tokio1Executor> {
    async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
        use tokio1_crate::io::AsyncWriteExt;

+        #[cfg(feature = "tracing")]
+        tracing::debug!(command = ?self.inner.command, "sending email with");
+
        let mut command = self.tokio1_command(envelope);

        // Spawn the sendmail command
--- a/src/transport/smtp/async_transport.rs
+++ b/src/transport/smtp/async_transport.rs
@@ -1,7 +1,8 @@
+#[cfg(feature = "pool")]
+use std::sync::Arc;
 use std::{
    fmt::{self, Debug},
    marker::PhantomData,
-    sync::Arc,
    time::Duration,
 };

--- a/src/transport/smtp/authentication.rs
+++ b/src/transport/smtp/authentication.rs
@@ -127,7 +127,7 @@ mod test {
    fn test_plain() {
        let mechanism = Mechanism::Plain;

-        let credentials = Credentials::new("username".to_string(), "password".to_string());
+        let credentials = Credentials::new("username".to_owned(), "password".to_owned());

        assert_eq!(
            mechanism.response(&credentials, None).unwrap(),
@@ -140,7 +140,7 @@ mod test {
    fn test_login() {
        let mechanism = Mechanism::Login;

-        let credentials = Credentials::new("alice".to_string(), "wonderland".to_string());
+        let credentials = Credentials::new("alice".to_owned(), "wonderland".to_owned());

        assert_eq!(
            mechanism.response(&credentials, Some("Username")).unwrap(),
@@ -158,8 +158,8 @@ mod test {
        let mechanism = Mechanism::Xoauth2;

        let credentials = Credentials::new(
-            "username".to_string(),
-            "vF9dft4qmTc2Nvb3RlckBhdHRhdmlzdGEuY29tCg==".to_string(),
+            "username".to_owned(),
+            "vF9dft4qmTc2Nvb3RlckBhdHRhdmlzdGEuY29tCg==".to_owned(),
        );

        assert_eq!(
@@ -172,7 +172,7 @@ mod test {
    #[test]
    fn test_from_user_pass_for_credentials() {
        assert_eq!(
-            Credentials::new("alice".to_string(), "wonderland".to_string()),
+            Credentials::new("alice".to_owned(), "wonderland".to_owned()),
            Credentials::from(("alice", "wonderland"))
        );
    }
--- a/src/transport/smtp/client/async_connection.rs
+++ b/src/transport/smtp/client/async_connection.rs
@@ -2,6 +2,8 @@ use std::{fmt::Display, net::IpAddr, time::Duration};

 use futures_util::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};

+#[cfg(feature = "tokio1")]
+use super::async_net::AsyncTokioStream;
 #[cfg(feature = "tracing")]
 use super::escape_crlf;
 use super::{AsyncNetworkStream, ClientCodec, TlsParameters};
@@ -46,6 +48,18 @@ impl AsyncSmtpConnection {
        &self.server_info
    }

+    /// Connects with existing async stream
+    ///
+    /// Sends EHLO and parses server information
+    #[cfg(feature = "tokio1")]
+    pub async fn connect_with_transport(
+        stream: Box<dyn AsyncTokioStream>,
+        hello_name: &ClientId,
+    ) -> Result<AsyncSmtpConnection, Error> {
+        let stream = AsyncNetworkStream::use_existing_tokio1(stream);
+        Self::connect_impl(stream, hello_name).await
+    }
+
    /// Connects to the configured server
    ///
    /// Sends EHLO and parses server information
@@ -194,6 +208,7 @@ impl AsyncSmtpConnection {
            self.panic = true;
            let _ = self.command(Quit).await;
        }
+        let _ = self.stream.close().await;
    }

    /// Sets the underlying stream
@@ -302,7 +317,7 @@ impl AsyncSmtpConnection {
                    } else {
                        Err(error::code(
                            response.code(),
-                            response.first_line().map(|s| s.to_owned()),
+                            Some(response.message().collect()),
                        ))
                    }
                }
@@ -320,7 +335,7 @@ impl AsyncSmtpConnection {
    }

    /// The X509 certificate of the server (DER encoded)
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
    pub fn peer_certificate(&self) -> Result<Vec<u8>, Error> {
        self.stream.get_ref().peer_certificate()
    }
--- a/src/transport/smtp/client/async_net.rs
+++ b/src/transport/smtp/client/async_net.rs
@@ -1,5 +1,5 @@
 use std::{
-    io, mem,
+    fmt, io, mem,
    net::{IpAddr, SocketAddr},
    pin::Pin,
    task::{Context, Poll},
@@ -16,8 +16,10 @@ use futures_io::{
 };
 #[cfg(feature = "async-std1-rustls-tls")]
 use futures_rustls::client::TlsStream as AsyncStd1RustlsTlsStream;
+#[cfg(feature = "tokio1-boring-tls")]
+use tokio1_boring::SslStream as Tokio1SslStream;
 #[cfg(feature = "tokio1")]
-use tokio1_crate::io::{AsyncRead as _, AsyncWrite as _, ReadBuf as Tokio1ReadBuf};
+use tokio1_crate::io::{AsyncRead, AsyncWrite, ReadBuf as Tokio1ReadBuf};
 #[cfg(feature = "tokio1")]
 use tokio1_crate::net::{
    TcpSocket as Tokio1TcpSocket, TcpStream as Tokio1TcpStream,
@@ -31,6 +33,7 @@ use tokio1_rustls::client::TlsStream as Tokio1RustlsTlsStream;
 #[cfg(any(
    feature = "tokio1-native-tls",
    feature = "tokio1-rustls-tls",
+    feature = "tokio1-boring-tls",
    feature = "async-std1-native-tls",
    feature = "async-std1-rustls-tls"
 ))]
@@ -41,25 +44,42 @@ use crate::transport::smtp::client::net::resolved_address_filter;
 use crate::transport::smtp::{error, Error};

 /// A network stream
+#[derive(Debug)]
 pub struct AsyncNetworkStream {
    inner: InnerAsyncNetworkStream,
 }

+#[cfg(feature = "tokio1")]
+pub trait AsyncTokioStream: AsyncRead + AsyncWrite + Send + Sync + Unpin + fmt::Debug {
+    fn peer_addr(&self) -> io::Result<SocketAddr>;
+}
+
+#[cfg(feature = "tokio1")]
+impl AsyncTokioStream for Tokio1TcpStream {
+    fn peer_addr(&self) -> io::Result<SocketAddr> {
+        self.peer_addr()
+    }
+}
+
 /// Represents the different types of underlying network streams
 // usually only one TLS backend at a time is going to be enabled,
 // so clippy::large_enum_variant doesn't make sense here
 #[allow(clippy::large_enum_variant)]
 #[allow(dead_code)]
+#[derive(Debug)]
 enum InnerAsyncNetworkStream {
    /// Plain Tokio 1.x TCP stream
    #[cfg(feature = "tokio1")]
-    Tokio1Tcp(Tokio1TcpStream),
+    Tokio1Tcp(Box<dyn AsyncTokioStream>),
    /// Encrypted Tokio 1.x TCP stream
    #[cfg(feature = "tokio1-native-tls")]
-    Tokio1NativeTls(Tokio1TlsStream<Tokio1TcpStream>),
+    Tokio1NativeTls(Tokio1TlsStream<Box<dyn AsyncTokioStream>>),
    /// Encrypted Tokio 1.x TCP stream
    #[cfg(feature = "tokio1-rustls-tls")]
-    Tokio1RustlsTls(Tokio1RustlsTlsStream<Tokio1TcpStream>),
+    Tokio1RustlsTls(Tokio1RustlsTlsStream<Box<dyn AsyncTokioStream>>),
+    /// Encrypted Tokio 1.x TCP stream
+    #[cfg(feature = "tokio1-boring-tls")]
+    Tokio1BoringTls(Tokio1SslStream<Box<dyn AsyncTokioStream>>),
    /// Plain Tokio 1.x TCP stream
    #[cfg(feature = "async-std1")]
    AsyncStd1Tcp(AsyncStd1TcpStream),
@@ -93,6 +113,8 @@ impl AsyncNetworkStream {
            }
            #[cfg(feature = "tokio1-rustls-tls")]
            InnerAsyncNetworkStream::Tokio1RustlsTls(ref s) => s.get_ref().0.peer_addr(),
+            #[cfg(feature = "tokio1-boring-tls")]
+            InnerAsyncNetworkStream::Tokio1BoringTls(ref s) => s.get_ref().peer_addr(),
            #[cfg(feature = "async-std1")]
            InnerAsyncNetworkStream::AsyncStd1Tcp(ref s) => s.peer_addr(),
            #[cfg(feature = "async-std1-native-tls")]
@@ -109,6 +131,11 @@ impl AsyncNetworkStream {
        }
    }

+    #[cfg(feature = "tokio1")]
+    pub fn use_existing_tokio1(stream: Box<dyn AsyncTokioStream>) -> AsyncNetworkStream {
+        AsyncNetworkStream::new(InnerAsyncNetworkStream::Tokio1Tcp(stream))
+    }
+
    #[cfg(feature = "tokio1")]
    pub async fn connect_tokio1<T: Tokio1ToSocketAddrs>(
        server: T,
@@ -167,7 +194,8 @@ impl AsyncNetworkStream {
        }

        let tcp_stream = try_connect(server, timeout, local_addr).await?;
-        let mut stream = AsyncNetworkStream::new(InnerAsyncNetworkStream::Tokio1Tcp(tcp_stream));
+        let mut stream =
+            AsyncNetworkStream::new(InnerAsyncNetworkStream::Tokio1Tcp(Box::new(tcp_stream)));
        if let Some(tls_parameters) = tls_parameters {
            stream.upgrade_tls(tls_parameters).await?;
        }
@@ -229,14 +257,22 @@ impl AsyncNetworkStream {
        match &self.inner {
            #[cfg(all(
                feature = "tokio1",
-                not(any(feature = "tokio1-native-tls", feature = "tokio1-rustls-tls"))
+                not(any(
+                    feature = "tokio1-native-tls",
+                    feature = "tokio1-rustls-tls",
+                    feature = "tokio1-boring-tls"
+                ))
            ))]
            InnerAsyncNetworkStream::Tokio1Tcp(_) => {
                let _ = tls_parameters;
                panic!("Trying to upgrade an AsyncNetworkStream without having enabled either the tokio1-native-tls or the tokio1-rustls-tls feature");
            }

-            #[cfg(any(feature = "tokio1-native-tls", feature = "tokio1-rustls-tls"))]
+            #[cfg(any(
+                feature = "tokio1-native-tls",
+                feature = "tokio1-rustls-tls",
+                feature = "tokio1-boring-tls"
+            ))]
            InnerAsyncNetworkStream::Tokio1Tcp(_) => {
                // get owned TcpStream
                let tcp_stream = mem::replace(&mut self.inner, InnerAsyncNetworkStream::None);
@@ -278,12 +314,16 @@ impl AsyncNetworkStream {
    }

    #[allow(unused_variables)]
-    #[cfg(any(feature = "tokio1-native-tls", feature = "tokio1-rustls-tls"))]
+    #[cfg(any(
+        feature = "tokio1-native-tls",
+        feature = "tokio1-rustls-tls",
+        feature = "tokio1-boring-tls"
+    ))]
    async fn upgrade_tokio1_tls(
-        tcp_stream: Tokio1TcpStream,
+        tcp_stream: Box<dyn AsyncTokioStream>,
        tls_parameters: TlsParameters,
    ) -> Result<InnerAsyncNetworkStream, Error> {
-        let domain = tls_parameters.domain().to_string();
+        let domain = tls_parameters.domain().to_owned();

        match tls_parameters.connector {
            #[cfg(feature = "native-tls")]
@@ -324,11 +364,31 @@ impl AsyncNetworkStream {
                    Ok(InnerAsyncNetworkStream::Tokio1RustlsTls(stream))
                };
            }
+            #[cfg(feature = "boring-tls")]
+            InnerTlsParameters::BoringTls(connector) => {
+                #[cfg(not(feature = "tokio1-boring-tls"))]
+                panic!("built without the tokio1-boring-tls feature");
+
+                #[cfg(feature = "tokio1-boring-tls")]
+                return {
+                    let mut config = connector.configure().map_err(error::connection)?;
+                    config.set_verify_hostname(tls_parameters.accept_invalid_hostnames);
+
+                    let stream = tokio1_boring::connect(config, &domain, tcp_stream)
+                        .await
+                        .map_err(error::connection)?;
+                    Ok(InnerAsyncNetworkStream::Tokio1BoringTls(stream))
+                };
+            }
        }
    }

    #[allow(unused_variables)]
-    #[cfg(any(feature = "async-std1-native-tls", feature = "async-std1-rustls-tls"))]
+    #[cfg(any(
+        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,
@@ -377,6 +437,10 @@ impl AsyncNetworkStream {
                    Ok(InnerAsyncNetworkStream::AsyncStd1RustlsTls(stream))
                };
            }
+            #[cfg(feature = "boring-tls")]
+            InnerTlsParameters::BoringTls(connector) => {
+                panic!("boring-tls isn't supported with async-std yet.");
+            }
        }
    }

@@ -388,6 +452,8 @@ impl AsyncNetworkStream {
            InnerAsyncNetworkStream::Tokio1NativeTls(_) => true,
            #[cfg(feature = "tokio1-rustls-tls")]
            InnerAsyncNetworkStream::Tokio1RustlsTls(_) => true,
+            #[cfg(feature = "tokio1-boring-tls")]
+            InnerAsyncNetworkStream::Tokio1BoringTls(_) => true,
            #[cfg(feature = "async-std1")]
            InnerAsyncNetworkStream::AsyncStd1Tcp(_) => false,
            #[cfg(feature = "async-std1-native-tls")]
@@ -422,6 +488,13 @@ impl AsyncNetworkStream {
                .unwrap()
                .clone()
                .0),
+            #[cfg(feature = "tokio1-boring-tls")]
+            InnerAsyncNetworkStream::Tokio1BoringTls(stream) => Ok(stream
+                .ssl()
+                .peer_certificate()
+                .unwrap()
+                .to_der()
+                .map_err(error::tls)?),
            #[cfg(feature = "async-std1")]
            InnerAsyncNetworkStream::AsyncStd1Tcp(_) => {
                Err(error::client("Connection is not encrypted"))
@@ -477,6 +550,15 @@ impl FuturesAsyncRead for AsyncNetworkStream {
                    Poll::Pending => Poll::Pending,
                }
            }
+            #[cfg(feature = "tokio1-boring-tls")]
+            InnerAsyncNetworkStream::Tokio1BoringTls(ref mut s) => {
+                let mut b = Tokio1ReadBuf::new(buf);
+                match Pin::new(s).poll_read(cx, &mut b) {
+                    Poll::Ready(Ok(())) => Poll::Ready(Ok(b.filled().len())),
+                    Poll::Ready(Err(err)) => Poll::Ready(Err(err)),
+                    Poll::Pending => Poll::Pending,
+                }
+            }
            #[cfg(feature = "async-std1")]
            InnerAsyncNetworkStream::AsyncStd1Tcp(ref mut s) => Pin::new(s).poll_read(cx, buf),
            #[cfg(feature = "async-std1-native-tls")]
@@ -508,6 +590,8 @@ impl FuturesAsyncWrite for AsyncNetworkStream {
            InnerAsyncNetworkStream::Tokio1NativeTls(ref mut s) => Pin::new(s).poll_write(cx, buf),
            #[cfg(feature = "tokio1-rustls-tls")]
            InnerAsyncNetworkStream::Tokio1RustlsTls(ref mut s) => Pin::new(s).poll_write(cx, buf),
+            #[cfg(feature = "tokio1-boring-tls")]
+            InnerAsyncNetworkStream::Tokio1BoringTls(ref mut s) => Pin::new(s).poll_write(cx, buf),
            #[cfg(feature = "async-std1")]
            InnerAsyncNetworkStream::AsyncStd1Tcp(ref mut s) => Pin::new(s).poll_write(cx, buf),
            #[cfg(feature = "async-std1-native-tls")]
@@ -533,6 +617,8 @@ impl FuturesAsyncWrite for AsyncNetworkStream {
            InnerAsyncNetworkStream::Tokio1NativeTls(ref mut s) => Pin::new(s).poll_flush(cx),
            #[cfg(feature = "tokio1-rustls-tls")]
            InnerAsyncNetworkStream::Tokio1RustlsTls(ref mut s) => Pin::new(s).poll_flush(cx),
+            #[cfg(feature = "tokio1-boring-tls")]
+            InnerAsyncNetworkStream::Tokio1BoringTls(ref mut s) => Pin::new(s).poll_flush(cx),
            #[cfg(feature = "async-std1")]
            InnerAsyncNetworkStream::AsyncStd1Tcp(ref mut s) => Pin::new(s).poll_flush(cx),
            #[cfg(feature = "async-std1-native-tls")]
@@ -554,6 +640,8 @@ impl FuturesAsyncWrite for AsyncNetworkStream {
            InnerAsyncNetworkStream::Tokio1NativeTls(ref mut s) => Pin::new(s).poll_shutdown(cx),
            #[cfg(feature = "tokio1-rustls-tls")]
            InnerAsyncNetworkStream::Tokio1RustlsTls(ref mut s) => Pin::new(s).poll_shutdown(cx),
+            #[cfg(feature = "tokio1-boring-tls")]
+            InnerAsyncNetworkStream::Tokio1BoringTls(ref mut s) => Pin::new(s).poll_shutdown(cx),
            #[cfg(feature = "async-std1")]
            InnerAsyncNetworkStream::AsyncStd1Tcp(ref mut s) => Pin::new(s).poll_close(cx),
            #[cfg(feature = "async-std1-native-tls")]
--- a/src/transport/smtp/client/connection.rs
+++ b/src/transport/smtp/client/connection.rs
@@ -143,7 +143,7 @@ impl SmtpConnection {
        hello_name: &ClientId,
    ) -> Result<(), Error> {
        if self.server_info.supports_feature(Extension::StartTls) {
-            #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+            #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
            {
                try_smtp!(self.command(Starttls), self);
                self.stream.get_mut().upgrade_tls(tls_parameters)?;
@@ -153,7 +153,11 @@ impl SmtpConnection {
                try_smtp!(self.ehlo(hello_name), self);
                Ok(())
            }
-            #[cfg(not(any(feature = "native-tls", feature = "rustls-tls")))]
+            #[cfg(not(any(
+                feature = "native-tls",
+                feature = "rustls-tls",
+                feature = "boring-tls"
+            )))]
            // This should never happen as `Tls` can only be created
            // when a TLS library is enabled
            unreachable!("TLS support required but not supported");
@@ -179,6 +183,7 @@ impl SmtpConnection {
            self.panic = true;
            let _ = self.command(Quit);
        }
+        let _ = self.stream.get_mut().shutdown(std::net::Shutdown::Both);
    }

    /// Sets the underlying stream
@@ -238,11 +243,12 @@ impl SmtpConnection {

    /// Sends the message content
    pub fn message(&mut self, message: &[u8]) -> Result<Response, Error> {
-        let mut out_buf: Vec<u8> = vec![];
        let mut codec = ClientCodec::new();
+        let mut out_buf = Vec::with_capacity(message.len());
        codec.encode(message, &mut out_buf);
        self.write(out_buf.as_slice())?;
        self.write(b"\r\n.\r\n")?;
+
        self.read_response()
    }

@@ -279,7 +285,7 @@ impl SmtpConnection {
                    } else {
                        Err(error::code(
                            response.code(),
-                            response.first_line().map(|s| s.to_owned()),
+                            Some(response.message().collect()),
                        ))
                    };
                }
@@ -297,7 +303,7 @@ impl SmtpConnection {
    }

    /// The X509 certificate of the server (DER encoded)
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
    pub fn peer_certificate(&self) -> Result<Vec<u8>, Error> {
        self.stream.get_ref().peer_certificate()
    }
--- a/src/transport/smtp/client/mod.rs
+++ b/src/transport/smtp/client/mod.rs
@@ -11,7 +11,7 @@
 //!     client::SmtpConnection, commands::*, extension::ClientId, SMTP_PORT,
 //! };
 //!
-//! let hello = ClientId::Domain("my_hostname".to_string());
+//! let hello = ClientId::Domain("my_hostname".to_owned());
 //! let mut client = SmtpConnection::connect(&("localhost", SMTP_PORT), None, &hello, None, None)?;
 //! client.command(Mail::new(Some("user@example.com".parse()?), vec![]))?;
 //! client.command(Rcpt::new("user@example.org".parse()?, vec![]))?;
@@ -29,12 +29,16 @@ use std::fmt::Debug;
 pub use self::async_connection::AsyncSmtpConnection;
 #[cfg(any(feature = "tokio1", feature = "async-std1"))]
 pub use self::async_net::AsyncNetworkStream;
+#[cfg(feature = "tokio1")]
+pub use self::async_net::AsyncTokioStream;
 use self::net::NetworkStream;
-#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+#[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
 pub(super) use self::tls::InnerTlsParameters;
+#[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+pub use self::tls::TlsVersion;
 pub use self::{
    connection::SmtpConnection,
-    tls::{Certificate, Tls, TlsParameters, TlsParametersBuilder},
+    tls::{Certificate, CertificateStore, Tls, TlsParameters, TlsParametersBuilder},
 };

 #[cfg(any(feature = "tokio1", feature = "async-std1"))]
@@ -46,60 +50,57 @@ mod net;
 mod tls;

 /// The codec used for transparency
-#[derive(Default, Clone, Copy, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Debug)]
 struct ClientCodec {
-    escape_count: u8,
+    status: CodecStatus,
 }

 impl ClientCodec {
    /// Creates a new client codec
    pub fn new() -> Self {
-        ClientCodec::default()
+        Self {
+            status: CodecStatus::StartOfNewLine,
+        }
    }

    /// Adds transparency
    fn encode(&mut self, frame: &[u8], buf: &mut Vec<u8>) {
-        match frame.len() {
-            0 => {
-                match self.escape_count {
-                    0 => buf.extend_from_slice(b"\r\n.\r\n"),
-                    1 => buf.extend_from_slice(b"\n.\r\n"),
-                    2 => buf.extend_from_slice(b".\r\n"),
-                    _ => unreachable!(),
+        for &b in frame {
+            buf.push(b);
+            match (b, self.status) {
+                (b'\r', _) => {
+                    self.status = CodecStatus::StartingNewLine;
                }
-                self.escape_count = 0;
-            }
-            _ => {
-                let mut start = 0;
-                for (idx, byte) in frame.iter().enumerate() {
-                    match self.escape_count {
-                        0 => self.escape_count = if *byte == b'\r' { 1 } else { 0 },
-                        1 => self.escape_count = if *byte == b'\n' { 2 } else { 0 },
-                        2 => {
-                            self.escape_count = if *byte == b'.' {
-                                3
-                            } else if *byte == b'\r' {
-                                1
-                            } else {
-                                0
-                            }
-                        }
-                        _ => unreachable!(),
-                    }
-                    if self.escape_count == 3 {
-                        self.escape_count = 0;
-                        buf.extend_from_slice(&frame[start..idx]);
-                        buf.extend_from_slice(b".");
-                        start = idx;
-                    }
+                (b'\n', CodecStatus::StartingNewLine) => {
+                    self.status = CodecStatus::StartOfNewLine;
                }
-                buf.extend_from_slice(&frame[start..]);
+                (_, CodecStatus::StartingNewLine) => {
+                    self.status = CodecStatus::MiddleOfLine;
+                }
+                (b'.', CodecStatus::StartOfNewLine) => {
+                    self.status = CodecStatus::MiddleOfLine;
+                    buf.push(b'.');
+                }
+                (_, CodecStatus::StartOfNewLine) => {
+                    self.status = CodecStatus::MiddleOfLine;
+                }
+                _ => {}
            }
        }
    }
 }

+#[derive(Debug, Copy, Clone)]
+#[allow(clippy::enum_variant_names)]
+enum CodecStatus {
+    /// We are past the first character of the current line
+    MiddleOfLine,
+    /// We just read a `\r` character
+    StartingNewLine,
+    /// We are at the start of a new line
+    StartOfNewLine,
+}
+
 /// Returns the string replacing all the CRLF with "\<CRLF\>"
 /// Used for debug displays
 #[cfg(feature = "tracing")]
@@ -113,9 +114,10 @@ mod test {

    #[test]
    fn test_codec() {
+        let mut buf = Vec::new();
        let mut codec = ClientCodec::new();
-        let mut buf: Vec<u8> = vec![];

+        codec.encode(b".\r\n", &mut buf);
        codec.encode(b"test\r\n", &mut buf);
        codec.encode(b"test\r\n\r\n", &mut buf);
        codec.encode(b".\r\n", &mut buf);
@@ -126,9 +128,13 @@ mod test {
        codec.encode(b"test\n", &mut buf);
        codec.encode(b".test\n", &mut buf);
        codec.encode(b"test", &mut buf);
+        codec.encode(b"test", &mut buf);
+        codec.encode(b"test\r\n", &mut buf);
+        codec.encode(b".test\r\n", &mut buf);
+        codec.encode(b"test.\r\n", &mut buf);
        assert_eq!(
            String::from_utf8(buf).unwrap(),
-            "test\r\ntest\r\n\r\n..\r\n\r\ntestte\r\n..\r\nsttesttest.test\n.test\ntest"
+            "..\r\ntest\r\ntest\r\n\r\n..\r\n\r\ntestte\r\n..\r\nsttesttest.test\n.test\ntesttesttest\r\n..test\r\ntest.\r\n"
        );
    }

--- a/src/transport/smtp/client/net.rs
+++ b/src/transport/smtp/client/net.rs
@@ -1,18 +1,21 @@
+#[cfg(feature = "rustls-tls")]
+use std::sync::Arc;
 use std::{
    io::{self, Read, Write},
    mem,
    net::{IpAddr, Ipv4Addr, Shutdown, SocketAddr, SocketAddrV4, TcpStream, ToSocketAddrs},
-    sync::Arc,
    time::Duration,
 };

+#[cfg(feature = "boring-tls")]
+use boring::ssl::SslStream;
 #[cfg(feature = "native-tls")]
 use native_tls::TlsStream;
 #[cfg(feature = "rustls-tls")]
 use rustls::{ClientConnection, ServerName, StreamOwned};
 use socket2::{Domain, Protocol, Type};

-#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+#[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
 use super::InnerTlsParameters;
 use super::TlsParameters;
 use crate::transport::smtp::{error, Error};
@@ -35,6 +38,8 @@ enum InnerNetworkStream {
    /// Encrypted TCP stream
    #[cfg(feature = "rustls-tls")]
    RustlsTls(StreamOwned<ClientConnection, TcpStream>),
+    #[cfg(feature = "boring-tls")]
+    BoringTls(SslStream<TcpStream>),
    /// Can't be built
    None,
 }
@@ -56,6 +61,8 @@ impl NetworkStream {
            InnerNetworkStream::NativeTls(ref s) => s.get_ref().peer_addr(),
            #[cfg(feature = "rustls-tls")]
            InnerNetworkStream::RustlsTls(ref s) => s.get_ref().peer_addr(),
+            #[cfg(feature = "boring-tls")]
+            InnerNetworkStream::BoringTls(ref s) => s.get_ref().peer_addr(),
            InnerNetworkStream::None => {
                debug_assert!(false, "InnerNetworkStream::None must never be built");
                Ok(SocketAddr::V4(SocketAddrV4::new(
@@ -74,6 +81,8 @@ impl NetworkStream {
            InnerNetworkStream::NativeTls(ref s) => s.get_ref().shutdown(how),
            #[cfg(feature = "rustls-tls")]
            InnerNetworkStream::RustlsTls(ref s) => s.get_ref().shutdown(how),
+            #[cfg(feature = "boring-tls")]
+            InnerNetworkStream::BoringTls(ref s) => s.get_ref().shutdown(how),
            InnerNetworkStream::None => {
                debug_assert!(false, "InnerNetworkStream::None must never be built");
                Ok(())
@@ -137,13 +146,17 @@ impl NetworkStream {

    pub fn upgrade_tls(&mut self, tls_parameters: &TlsParameters) -> Result<(), Error> {
        match &self.inner {
-            #[cfg(not(any(feature = "native-tls", feature = "rustls-tls")))]
+            #[cfg(not(any(
+                feature = "native-tls",
+                feature = "rustls-tls",
+                feature = "boring-tls"
+            )))]
            InnerNetworkStream::Tcp(_) => {
                let _ = tls_parameters;
                panic!("Trying to upgrade an NetworkStream without having enabled either the native-tls or the rustls-tls feature");
            }

-            #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+            #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
            InnerNetworkStream::Tcp(_) => {
                // get owned TcpStream
                let tcp_stream = mem::replace(&mut self.inner, InnerNetworkStream::None);
@@ -159,7 +172,7 @@ impl NetworkStream {
        }
    }

-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
    fn upgrade_tls_impl(
        tcp_stream: TcpStream,
        tls_parameters: &TlsParameters,
@@ -181,6 +194,16 @@ impl NetworkStream {
                let stream = StreamOwned::new(connection, tcp_stream);
                InnerNetworkStream::RustlsTls(stream)
            }
+            #[cfg(feature = "boring-tls")]
+            InnerTlsParameters::BoringTls(connector) => {
+                let stream = connector
+                    .configure()
+                    .map_err(error::connection)?
+                    .verify_hostname(tls_parameters.accept_invalid_hostnames)
+                    .connect(tls_parameters.domain(), tcp_stream)
+                    .map_err(error::connection)?;
+                InnerNetworkStream::BoringTls(stream)
+            }
        })
    }

@@ -191,6 +214,8 @@ impl NetworkStream {
            InnerNetworkStream::NativeTls(_) => true,
            #[cfg(feature = "rustls-tls")]
            InnerNetworkStream::RustlsTls(_) => true,
+            #[cfg(feature = "boring-tls")]
+            InnerNetworkStream::BoringTls(_) => true,
            InnerNetworkStream::None => {
                debug_assert!(false, "InnerNetworkStream::None must never be built");
                false
@@ -198,7 +223,7 @@ impl NetworkStream {
        }
    }

-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
    pub fn peer_certificate(&self) -> Result<Vec<u8>, Error> {
        match &self.inner {
            InnerNetworkStream::Tcp(_) => Err(error::client("Connection is not encrypted")),
@@ -218,6 +243,13 @@ impl NetworkStream {
                .unwrap()
                .clone()
                .0),
+            #[cfg(feature = "boring-tls")]
+            InnerNetworkStream::BoringTls(stream) => Ok(stream
+                .ssl()
+                .peer_certificate()
+                .unwrap()
+                .to_der()
+                .map_err(error::tls)?),
            InnerNetworkStream::None => panic!("InnerNetworkStream::None must never be built"),
        }
    }
@@ -233,6 +265,10 @@ impl NetworkStream {
            InnerNetworkStream::RustlsTls(ref mut stream) => {
                stream.get_ref().set_read_timeout(duration)
            }
+            #[cfg(feature = "boring-tls")]
+            InnerNetworkStream::BoringTls(ref mut stream) => {
+                stream.get_ref().set_read_timeout(duration)
+            }
            InnerNetworkStream::None => {
                debug_assert!(false, "InnerNetworkStream::None must never be built");
                Ok(())
@@ -253,7 +289,10 @@ impl NetworkStream {
            InnerNetworkStream::RustlsTls(ref mut stream) => {
                stream.get_ref().set_write_timeout(duration)
            }
-
+            #[cfg(feature = "boring-tls")]
+            InnerNetworkStream::BoringTls(ref mut stream) => {
+                stream.get_ref().set_write_timeout(duration)
+            }
            InnerNetworkStream::None => {
                debug_assert!(false, "InnerNetworkStream::None must never be built");
                Ok(())
@@ -270,6 +309,8 @@ impl Read for NetworkStream {
            InnerNetworkStream::NativeTls(ref mut s) => s.read(buf),
            #[cfg(feature = "rustls-tls")]
            InnerNetworkStream::RustlsTls(ref mut s) => s.read(buf),
+            #[cfg(feature = "boring-tls")]
+            InnerNetworkStream::BoringTls(ref mut s) => s.read(buf),
            InnerNetworkStream::None => {
                debug_assert!(false, "InnerNetworkStream::None must never be built");
                Ok(0)
@@ -286,6 +327,8 @@ impl Write for NetworkStream {
            InnerNetworkStream::NativeTls(ref mut s) => s.write(buf),
            #[cfg(feature = "rustls-tls")]
            InnerNetworkStream::RustlsTls(ref mut s) => s.write(buf),
+            #[cfg(feature = "boring-tls")]
+            InnerNetworkStream::BoringTls(ref mut s) => s.write(buf),
            InnerNetworkStream::None => {
                debug_assert!(false, "InnerNetworkStream::None must never be built");
                Ok(0)
@@ -300,6 +343,8 @@ impl Write for NetworkStream {
            InnerNetworkStream::NativeTls(ref mut s) => s.flush(),
            #[cfg(feature = "rustls-tls")]
            InnerNetworkStream::RustlsTls(ref mut s) => s.flush(),
+            #[cfg(feature = "boring-tls")]
+            InnerNetworkStream::BoringTls(ref mut s) => s.flush(),
            InnerNetworkStream::None => {
                debug_assert!(false, "InnerNetworkStream::None must never be built");
                Ok(())
--- a/src/transport/smtp/client/tls.rs
+++ b/src/transport/smtp/client/tls.rs
@@ -2,22 +2,57 @@ use std::fmt::{self, Debug};
 #[cfg(feature = "rustls-tls")]
 use std::{sync::Arc, time::SystemTime};

+#[cfg(feature = "boring-tls")]
+use boring::{
+    ssl::{SslConnector, SslVersion},
+    x509::store::X509StoreBuilder,
+};
 #[cfg(feature = "native-tls")]
 use native_tls::{Protocol, TlsConnector};
 #[cfg(feature = "rustls-tls")]
 use rustls::{
    client::{ServerCertVerified, ServerCertVerifier, WebPkiVerifier},
-    ClientConfig, Error as TlsError, OwnedTrustAnchor, RootCertStore, ServerName,
+    ClientConfig, Error as TlsError, RootCertStore, ServerName,
 };

-#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+#[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
 use crate::transport::smtp::{error, Error};

-/// Accepted protocols by default.
-/// This removes TLS 1.0 and 1.1 compared to tls-native defaults.
-// This is also rustls' default behavior
-#[cfg(feature = "native-tls")]
-const DEFAULT_TLS_MIN_PROTOCOL: Protocol = Protocol::Tlsv12;
+/// TLS protocol versions.
+#[derive(Debug, Copy, Clone)]
+#[non_exhaustive]
+#[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+pub enum TlsVersion {
+    /// TLS 1.0
+    ///
+    /// Should only be used when trying to support legacy
+    /// SMTP servers that haven't updated to
+    /// at least TLS 1.2 yet.
+    ///
+    /// Supported by `native-tls` and `boring-tls`.
+    Tlsv10,
+    /// TLS 1.1
+    ///
+    /// Should only be used when trying to support legacy
+    /// SMTP servers that haven't updated to
+    /// at least TLS 1.2 yet.
+    ///
+    /// Supported by `native-tls` and `boring-tls`.
+    Tlsv11,
+    /// TLS 1.2
+    ///
+    /// A good option for most SMTP servers.
+    ///
+    /// Supported by all TLS backends.
+    Tlsv12,
+    /// TLS 1.3
+    ///
+    /// The most secure option, altough not supported by all SMTP servers.
+    ///
+    /// Altough it is technically supported by all TLS backends,
+    /// trying to set it for `native-tls` will give a runtime error.
+    Tlsv13,
+}

 /// How to apply TLS to a client connection
 #[derive(Clone)]
@@ -26,16 +61,25 @@ pub enum Tls {
    /// Insecure connection only (for testing purposes)
    None,
    /// Start with insecure connection and use `STARTTLS` when available
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
    Opportunistic(TlsParameters),
    /// Start with insecure connection and require `STARTTLS`
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
    Required(TlsParameters),
    /// Use TLS wrapped connection
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
    Wrapper(TlsParameters),
 }

@@ -43,31 +87,65 @@ impl Debug for Tls {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match &self {
            Self::None => f.pad("None"),
-            #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+            #[cfg(any(feature = "native-tls", feature = "rustls", feature = "boring-tls"))]
            Self::Opportunistic(_) => f.pad("Opportunistic"),
-            #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+            #[cfg(any(feature = "native-tls", feature = "rustls", feature = "boring-tls"))]
            Self::Required(_) => f.pad("Required"),
-            #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+            #[cfg(any(feature = "native-tls", feature = "rustls", feature = "boring-tls"))]
            Self::Wrapper(_) => f.pad("Wrapper"),
        }
    }
 }

+/// Source for the base set of root certificates to trust.
+#[allow(missing_copy_implementations)]
+#[derive(Clone, Debug)]
+pub enum CertificateStore {
+    /// Use the default for the TLS backend.
+    ///
+    /// For native-tls, this will use the system certificate store on Windows, the keychain on
+    /// macOS, and OpenSSL directories on Linux (usually `/etc/ssl`).
+    ///
+    /// For rustls, this will also use the the system store if the `rustls-native-certs` feature is
+    /// enabled, or will fall back to `webpki-roots`.
+    ///
+    /// The boring-tls backend uses the same logic as OpenSSL on all platforms.
+    Default,
+    /// 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")]
+    WebpkiRoots,
+    /// Don't use any system certificates.
+    None,
+}
+
+impl Default for CertificateStore {
+    fn default() -> Self {
+        CertificateStore::Default
+    }
+}
+
 /// Parameters to use for secure clients
 #[derive(Clone)]
 pub struct TlsParameters {
    pub(crate) connector: InnerTlsParameters,
    /// The domain name which is expected in the TLS certificate from the server
    pub(super) domain: String,
+    #[cfg(feature = "boring-tls")]
+    pub(super) accept_invalid_hostnames: bool,
 }

 /// Builder for `TlsParameters`
 #[derive(Debug, Clone)]
 pub struct TlsParametersBuilder {
    domain: String,
+    cert_store: CertificateStore,
    root_certs: Vec<Certificate>,
    accept_invalid_hostnames: bool,
    accept_invalid_certs: bool,
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    min_tls_version: TlsVersion,
 }

 impl TlsParametersBuilder {
@@ -75,12 +153,21 @@ impl TlsParametersBuilder {
    pub fn new(domain: String) -> Self {
        Self {
            domain,
+            cert_store: CertificateStore::Default,
            root_certs: Vec::new(),
            accept_invalid_hostnames: false,
            accept_invalid_certs: false,
+            #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+            min_tls_version: TlsVersion::Tlsv12,
        }
    }

+    /// Set the source for the base set of root certificates to trust.
+    pub fn certificate_store(mut self, cert_store: CertificateStore) -> Self {
+        self.cert_store = cert_store;
+        self
+    }
+
    /// Add a custom root certificate
    ///
    /// Can be used to safely connect to a server using a self signed certificate, for example.
@@ -102,13 +189,22 @@ impl TlsParametersBuilder {
    /// This method introduces significant vulnerabilities to man-in-the-middle attacks.
    ///
    /// Hostname verification can only be disabled with the `native-tls` TLS backend.
-    #[cfg(feature = "native-tls")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "native-tls")))]
+    #[cfg(any(feature = "native-tls", feature = "boring-tls"))]
+    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "boring-tls"))))]
    pub fn dangerous_accept_invalid_hostnames(mut self, accept_invalid_hostnames: bool) -> Self {
        self.accept_invalid_hostnames = accept_invalid_hostnames;
        self
    }

+    /// Controls which minimum TLS version is allowed
+    ///
+    /// Defaults to [`Tlsv12`][TlsVersion::Tlsv12].
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    pub fn set_min_tls_version(mut self, min_tls_version: TlsVersion) -> Self {
+        self.min_tls_version = min_tls_version;
+        self
+    }
+
    /// Controls whether invalid certificates are accepted
    ///
    /// Defaults to `false`.
@@ -130,16 +226,20 @@ impl TlsParametersBuilder {
        self
    }

-    /// Creates a new `TlsParameters` using native-tls or rustls
+    /// Creates a new `TlsParameters` using native-tls, boring-tls or rustls
    /// depending on which one is available
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
    pub fn build(self) -> Result<TlsParameters, Error> {
        #[cfg(feature = "rustls-tls")]
        return self.build_rustls();
-
-        #[cfg(not(feature = "rustls-tls"))]
+        #[cfg(all(not(feature = "rustls-tls"), feature = "native-tls"))]
        return self.build_native();
+        #[cfg(all(not(feature = "rustls-tls"), feature = "boring-tls"))]
+        return self.build_boring();
    }

    /// Creates a new `TlsParameters` using native-tls with the provided configuration
@@ -148,17 +248,93 @@ impl TlsParametersBuilder {
    pub fn build_native(self) -> Result<TlsParameters, Error> {
        let mut tls_builder = TlsConnector::builder();

+        match self.cert_store {
+            CertificateStore::Default => {}
+            CertificateStore::None => {
+                tls_builder.disable_built_in_roots(true);
+            }
+            #[allow(unreachable_patterns)]
+            other => {
+                return Err(error::tls(format!(
+                    "{other:?} is not supported in native tls"
+                )))
+            }
+        }
        for cert in self.root_certs {
            tls_builder.add_root_certificate(cert.native_tls);
        }
        tls_builder.danger_accept_invalid_hostnames(self.accept_invalid_hostnames);
        tls_builder.danger_accept_invalid_certs(self.accept_invalid_certs);

-        tls_builder.min_protocol_version(Some(DEFAULT_TLS_MIN_PROTOCOL));
+        let min_tls_version = match self.min_tls_version {
+            TlsVersion::Tlsv10 => Protocol::Tlsv10,
+            TlsVersion::Tlsv11 => Protocol::Tlsv11,
+            TlsVersion::Tlsv12 => Protocol::Tlsv12,
+            TlsVersion::Tlsv13 => {
+                return Err(error::tls(
+                    "min tls version Tlsv13 not supported in native tls",
+                ))
+            }
+        };
+
+        tls_builder.min_protocol_version(Some(min_tls_version));
        let connector = tls_builder.build().map_err(error::tls)?;
        Ok(TlsParameters {
            connector: InnerTlsParameters::NativeTls(connector),
            domain: self.domain,
+            #[cfg(feature = "boring-tls")]
+            accept_invalid_hostnames: self.accept_invalid_hostnames,
+        })
+    }
+
+    /// Creates a new `TlsParameters` using boring-tls with the provided configuration
+    #[cfg(feature = "boring-tls")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "boring-tls")))]
+    pub fn build_boring(self) -> Result<TlsParameters, Error> {
+        use boring::ssl::{SslMethod, SslVerifyMode};
+
+        let mut tls_builder = SslConnector::builder(SslMethod::tls_client()).map_err(error::tls)?;
+
+        if self.accept_invalid_certs {
+            tls_builder.set_verify(SslVerifyMode::NONE);
+        } else {
+            match self.cert_store {
+                CertificateStore::Default => {}
+                CertificateStore::None => {
+                    // Replace the default store with an empty store.
+                    tls_builder
+                        .set_cert_store(X509StoreBuilder::new().map_err(error::tls)?.build());
+                }
+                #[allow(unreachable_patterns)]
+                other => {
+                    return Err(error::tls(format!(
+                        "{other:?} is not supported in boring tls"
+                    )))
+                }
+            }
+
+            let cert_store = tls_builder.cert_store_mut();
+
+            for cert in self.root_certs {
+                cert_store.add_cert(cert.boring_tls).map_err(error::tls)?;
+            }
+        }
+
+        let min_tls_version = match self.min_tls_version {
+            TlsVersion::Tlsv10 => SslVersion::TLS1,
+            TlsVersion::Tlsv11 => SslVersion::TLS1_1,
+            TlsVersion::Tlsv12 => SslVersion::TLS1_2,
+            TlsVersion::Tlsv13 => SslVersion::TLS1_3,
+        };
+
+        tls_builder
+            .set_min_proto_version(Some(min_tls_version))
+            .map_err(error::tls)?;
+        let connector = tls_builder.build();
+        Ok(TlsParameters {
+            connector: InnerTlsParameters::BoringTls(connector),
+            domain: self.domain,
+            accept_invalid_hostnames: self.accept_invalid_hostnames,
        })
    }

@@ -167,26 +343,81 @@ impl TlsParametersBuilder {
    #[cfg_attr(docsrs, doc(cfg(feature = "rustls-tls")))]
    pub fn build_rustls(self) -> Result<TlsParameters, Error> {
        let tls = ClientConfig::builder();
-        let tls = tls.with_safe_defaults();
+
+        let just_version3 = &[&rustls::version::TLS13];
+        let supported_versions = match self.min_tls_version {
+            TlsVersion::Tlsv10 => {
+                return Err(error::tls("min tls version Tlsv10 not supported in rustls"))
+            }
+            TlsVersion::Tlsv11 => {
+                return Err(error::tls("min tls version Tlsv11 not supported in rustls"))
+            }
+            TlsVersion::Tlsv12 => rustls::ALL_VERSIONS,
+            TlsVersion::Tlsv13 => just_version3,
+        };
+
+        let tls = tls
+            .with_safe_default_cipher_suites()
+            .with_safe_default_kx_groups()
+            .with_protocol_versions(supported_versions)
+            .map_err(error::tls)?;

        let tls = if self.accept_invalid_certs {
            tls.with_custom_certificate_verifier(Arc::new(InvalidCertsVerifier {}))
        } else {
            let mut root_cert_store = RootCertStore::empty();
+
+            #[cfg(feature = "rustls-native-certs")]
+            fn load_native_roots(store: &mut RootCertStore) -> Result<(), Error> {
+                let native_certs = rustls_native_certs::load_native_certs().map_err(error::tls)?;
+                let mut valid_count = 0;
+                let mut invalid_count = 0;
+                for cert in native_certs {
+                    match store.add(&rustls::Certificate(cert.0)) {
+                        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)?;
                }
            }
-            root_cert_store.add_server_trust_anchors(webpki_roots::TLS_SERVER_ROOTS.0.iter().map(
-                |ta| {
-                    OwnedTrustAnchor::from_subject_spki_name_constraints(
-                        ta.subject,
-                        ta.spki,
-                        ta.name_constraints,
-                    )
-                },
-            ));

            tls.with_custom_certificate_verifier(Arc::new(WebPkiVerifier::new(
                root_cert_store,
@@ -198,23 +429,31 @@ impl TlsParametersBuilder {
        Ok(TlsParameters {
            connector: InnerTlsParameters::RustlsTls(Arc::new(tls)),
            domain: self.domain,
+            #[cfg(feature = "boring-tls")]
+            accept_invalid_hostnames: self.accept_invalid_hostnames,
        })
    }
 }

 #[derive(Clone)]
+#[allow(clippy::enum_variant_names)]
 pub enum InnerTlsParameters {
    #[cfg(feature = "native-tls")]
    NativeTls(TlsConnector),
    #[cfg(feature = "rustls-tls")]
    RustlsTls(Arc<ClientConfig>),
+    #[cfg(feature = "boring-tls")]
+    BoringTls(SslConnector),
 }

 impl TlsParameters {
    /// Creates a new `TlsParameters` using native-tls or rustls
    /// depending on which one is available
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
    pub fn new(domain: String) -> Result<Self, Error> {
        TlsParametersBuilder::new(domain).build()
    }
@@ -238,6 +477,13 @@ impl TlsParameters {
        TlsParametersBuilder::new(domain).build_rustls()
    }

+    /// Creates a new `TlsParameters` using boring
+    #[cfg(feature = "boring-tls")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "boring-tls")))]
+    pub fn new_boring(domain: String) -> Result<Self, Error> {
+        TlsParametersBuilder::new(domain).build_boring()
+    }
+
    pub fn domain(&self) -> &str {
        &self.domain
    }
@@ -251,20 +497,27 @@ pub struct Certificate {
    native_tls: native_tls::Certificate,
    #[cfg(feature = "rustls-tls")]
    rustls: Vec<rustls::Certificate>,
+    #[cfg(feature = "boring-tls")]
+    boring_tls: boring::x509::X509,
 }

-#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+#[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
 impl Certificate {
    /// Create a `Certificate` from a DER encoded certificate
    pub fn from_der(der: Vec<u8>) -> Result<Self, Error> {
        #[cfg(feature = "native-tls")]
        let native_tls_cert = native_tls::Certificate::from_der(&der).map_err(error::tls)?;

+        #[cfg(feature = "boring-tls")]
+        let boring_tls_cert = boring::x509::X509::from_der(&der).map_err(error::tls)?;
+
        Ok(Self {
            #[cfg(feature = "native-tls")]
            native_tls: native_tls_cert,
            #[cfg(feature = "rustls-tls")]
            rustls: vec![rustls::Certificate(der)],
+            #[cfg(feature = "boring-tls")]
+            boring_tls: boring_tls_cert,
        })
    }

@@ -273,6 +526,9 @@ impl Certificate {
        #[cfg(feature = "native-tls")]
        let native_tls_cert = native_tls::Certificate::from_pem(pem).map_err(error::tls)?;

+        #[cfg(feature = "boring-tls")]
+        let boring_tls_cert = boring::x509::X509::from_pem(pem).map_err(error::tls)?;
+
        #[cfg(feature = "rustls-tls")]
        let rustls_cert = {
            use std::io::Cursor;
@@ -290,6 +546,8 @@ impl Certificate {
            native_tls: native_tls_cert,
            #[cfg(feature = "rustls-tls")]
            rustls: rustls_cert,
+            #[cfg(feature = "boring-tls")]
+            boring_tls: boring_tls_cert,
        })
    }
 }
--- a/src/transport/smtp/commands.rs
+++ b/src/transport/smtp/commands.rs
@@ -59,7 +59,7 @@ impl Display for Mail {
            self.sender.as_ref().map_or("", |s| s.as_ref())
        )?;
        for parameter in &self.parameters {
-            write!(f, " {}", parameter)?;
+            write!(f, " {parameter}")?;
        }
        f.write_str("\r\n")
    }
@@ -84,7 +84,7 @@ impl Display for Rcpt {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "RCPT TO:<{}>", self.recipient)?;
        for parameter in &self.parameters {
-            write!(f, " {}", parameter)?;
+            write!(f, " {parameter}")?;
        }
        f.write_str("\r\n")
    }
@@ -144,7 +144,7 @@ impl Display for Help {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        f.write_str("HELP")?;
        if let Some(argument) = &self.argument {
-            write!(f, " {}", argument)?;
+            write!(f, " {argument}")?;
        }
        f.write_str("\r\n")
    }
@@ -220,7 +220,7 @@ pub struct Auth {

 impl Display for Auth {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        let encoded_response = self.response.as_ref().map(base64::encode);
+        let encoded_response = self.response.as_ref().map(crate::base64::encode);

        if self.mechanism.supports_initial_response() {
            write!(f, "AUTH {} {}", self.mechanism, encoded_response.unwrap())?;
@@ -271,7 +271,7 @@ impl Auth {
        #[cfg(feature = "tracing")]
        tracing::debug!("auth encoded challenge: {}", encoded_challenge);

-        let decoded_base64 = base64::decode(&encoded_challenge).map_err(error::response)?;
+        let decoded_base64 = crate::base64::decode(encoded_challenge).map_err(error::response)?;
        let decoded_challenge = String::from_utf8(decoded_base64).map_err(error::response)?;
        #[cfg(feature = "tracing")]
        tracing::debug!("auth decoded challenge: {}", decoded_challenge);
@@ -296,15 +296,15 @@ mod test {

    #[test]
    fn test_display() {
-        let id = ClientId::Domain("localhost".to_string());
+        let id = ClientId::Domain("localhost".to_owned());
        let email = Address::from_str("test@example.com").unwrap();
        let mail_parameter = MailParameter::Other {
-            keyword: "TEST".to_string(),
-            value: Some("value".to_string()),
+            keyword: "TEST".to_owned(),
+            value: Some("value".to_owned()),
        };
        let rcpt_parameter = RcptParameter::Other {
-            keyword: "TEST".to_string(),
-            value: Some("value".to_string()),
+            keyword: "TEST".to_owned(),
+            value: Some("value".to_owned()),
        };
        assert_eq!(format!("{}", Ehlo::new(id)), "EHLO localhost\r\n");
        assert_eq!(
@@ -341,24 +341,18 @@ mod test {
            format!("{}", Rcpt::new(email, vec![rcpt_parameter])),
            "RCPT TO:<test@example.com> TEST=value\r\n"
        );
-        assert_eq!(format!("{}", Quit), "QUIT\r\n");
-        assert_eq!(format!("{}", Data), "DATA\r\n");
-        assert_eq!(format!("{}", Noop), "NOOP\r\n");
+        assert_eq!(format!("{Quit}"), "QUIT\r\n");
+        assert_eq!(format!("{Data}"), "DATA\r\n");
+        assert_eq!(format!("{Noop}"), "NOOP\r\n");
        assert_eq!(format!("{}", Help::new(None)), "HELP\r\n");
        assert_eq!(
-            format!("{}", Help::new(Some("test".to_string()))),
+            format!("{}", Help::new(Some("test".to_owned()))),
            "HELP test\r\n"
        );
-        assert_eq!(
-            format!("{}", Vrfy::new("test".to_string())),
-            "VRFY test\r\n"
-        );
-        assert_eq!(
-            format!("{}", Expn::new("test".to_string())),
-            "EXPN test\r\n"
-        );
-        assert_eq!(format!("{}", Rset), "RSET\r\n");
-        let credentials = Credentials::new("user".to_string(), "password".to_string());
+        assert_eq!(format!("{}", Vrfy::new("test".to_owned())), "VRFY test\r\n");
+        assert_eq!(format!("{}", Expn::new("test".to_owned())), "EXPN test\r\n");
+        assert_eq!(format!("{Rset}"), "RSET\r\n");
+        let credentials = Credentials::new("user".to_owned(), "password".to_owned());
        assert_eq!(
            format!(
                "{}",
--- a/src/transport/smtp/error.rs
+++ b/src/transport/smtp/error.rs
@@ -68,8 +68,11 @@ impl Error {
    }

    /// Returns true if the error is from TLS
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
    pub fn is_tls(&self) -> bool {
        matches!(self.inner.kind, Kind::Tls)
    }
@@ -102,8 +105,11 @@ pub(crate) enum Kind {
    /// Underlying network i/o error
    Network,
    /// TLS error
-    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
    Tls,
 }

@@ -128,18 +134,18 @@ impl fmt::Display for Error {
            Kind::Client => f.write_str("internal client error")?,
            Kind::Network => f.write_str("network error")?,
            Kind::Connection => f.write_str("Connection error")?,
-            #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+            #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
            Kind::Tls => f.write_str("tls error")?,
            Kind::Transient(ref code) => {
-                write!(f, "transient error ({})", code)?;
+                write!(f, "transient error ({code})")?;
            }
            Kind::Permanent(ref code) => {
-                write!(f, "permanent error ({})", code)?;
+                write!(f, "permanent error ({code})")?;
            }
        };

        if let Some(ref e) = self.inner.source {
-            write!(f, ": {}", e)?;
+            write!(f, ": {e}")?;
        }

        Ok(())
@@ -179,7 +185,7 @@ pub(crate) fn connection<E: Into<BoxError>>(e: E) -> Error {
    Error::new(Kind::Connection, Some(e))
 }

-#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+#[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
 pub(crate) fn tls<E: Into<BoxError>>(e: E) -> Error {
    Error::new(Kind::Tls, Some(e))
 }
--- a/src/transport/smtp/extension.rs
+++ b/src/transport/smtp/extension.rs
@@ -55,8 +55,8 @@ impl Display for ClientId {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match *self {
            Self::Domain(ref value) => f.write_str(value),
-            Self::Ipv4(ref value) => write!(f, "[{}]", value),
-            Self::Ipv6(ref value) => write!(f, "[IPv6:{}]", value),
+            Self::Ipv4(ref value) => write!(f, "[{value}]"),
+            Self::Ipv6(ref value) => write!(f, "[IPv6:{value}]"),
        }
    }
 }
@@ -97,7 +97,7 @@ impl Display for Extension {
            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(ref mechanism) => write!(f, "AUTH {mechanism}"),
        }
    }
 }
@@ -119,7 +119,7 @@ pub struct ServerInfo {
 impl Display for ServerInfo {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        let features = if self.features.is_empty() {
-            "no supported features".to_string()
+            "no supported features".to_owned()
        } else {
            format!("{:?}", self.features)
        };
@@ -174,7 +174,7 @@ impl ServerInfo {
        }

        Ok(ServerInfo {
-            name: name.to_string(),
+            name: name.to_owned(),
            features,
        })
    }
@@ -228,8 +228,8 @@ pub enum MailParameter {
 impl Display for MailParameter {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match *self {
-            MailParameter::Body(ref value) => write!(f, "BODY={}", value),
-            MailParameter::Size(size) => write!(f, "SIZE={}", size),
+            MailParameter::Body(ref value) => write!(f, "BODY={value}"),
+            MailParameter::Size(size) => write!(f, "SIZE={size}"),
            MailParameter::SmtpUtfEight => f.write_str("SMTPUTF8"),
            MailParameter::Other {
                ref keyword,
@@ -304,21 +304,21 @@ mod test {
    #[test]
    fn test_clientid_fmt() {
        assert_eq!(
-            format!("{}", ClientId::Domain("test".to_string())),
-            "test".to_string()
+            format!("{}", ClientId::Domain("test".to_owned())),
+            "test".to_owned()
        );
-        assert_eq!(format!("{}", LOCALHOST_CLIENT), "[127.0.0.1]".to_string());
+        assert_eq!(format!("{LOCALHOST_CLIENT}"), "[127.0.0.1]".to_owned());
    }

    #[test]
    fn test_extension_fmt() {
        assert_eq!(
            format!("{}", Extension::EightBitMime),
-            "8BITMIME".to_string()
+            "8BITMIME".to_owned()
        );
        assert_eq!(
            format!("{}", Extension::Authentication(Mechanism::Plain)),
-            "AUTH PLAIN".to_string()
+            "AUTH PLAIN".to_owned()
        );
    }

@@ -331,11 +331,11 @@ mod test {
            format!(
                "{}",
                ServerInfo {
-                    name: "name".to_string(),
+                    name: "name".to_owned(),
                    features: eightbitmime,
                }
            ),
-            "name with {EightBitMime}".to_string()
+            "name with {EightBitMime}".to_owned()
        );

        let empty = HashSet::new();
@@ -344,11 +344,11 @@ mod test {
            format!(
                "{}",
                ServerInfo {
-                    name: "name".to_string(),
+                    name: "name".to_owned(),
                    features: empty,
                }
            ),
-            "name with no supported features".to_string()
+            "name with no supported features".to_owned()
        );

        let mut plain = HashSet::new();
@@ -358,11 +358,11 @@ mod test {
            format!(
                "{}",
                ServerInfo {
-                    name: "name".to_string(),
+                    name: "name".to_owned(),
                    features: plain,
                }
            ),
-            "name with {Authentication(Plain)}".to_string()
+            "name with {Authentication(Plain)}".to_owned()
        );
    }

@@ -374,18 +374,14 @@ mod test {
                Category::Unspecified4,
                Detail::One,
            ),
-            vec![
-                "me".to_string(),
-                "8BITMIME".to_string(),
-                "SIZE 42".to_string(),
-            ],
+            vec!["me".to_owned(), "8BITMIME".to_owned(), "SIZE 42".to_owned()],
        );

        let mut features = HashSet::new();
        assert!(features.insert(Extension::EightBitMime));

        let server_info = ServerInfo {
-            name: "me".to_string(),
+            name: "me".to_owned(),
            features,
        };

@@ -401,10 +397,10 @@ mod test {
                Detail::One,
            ),
            vec![
-                "me".to_string(),
-                "AUTH PLAIN CRAM-MD5 XOAUTH2 OTHER".to_string(),
-                "8BITMIME".to_string(),
-                "SIZE 42".to_string(),
+                "me".to_owned(),
+                "AUTH PLAIN CRAM-MD5 XOAUTH2 OTHER".to_owned(),
+                "8BITMIME".to_owned(),
+                "SIZE 42".to_owned(),
            ],
        );

@@ -414,7 +410,7 @@ mod test {
        assert!(features2.insert(Extension::Authentication(Mechanism::Xoauth2),));

        let server_info2 = ServerInfo {
-            name: "me".to_string(),
+            name: "me".to_owned(),
            features: features2,
        };

--- a/src/transport/smtp/mod.rs
+++ b/src/transport/smtp/mod.rs
@@ -77,8 +77,8 @@
 //! let sender = SmtpTransport::starttls_relay("smtp.example.com")?
 //!     // Add credentials for authentication
 //!     .credentials(Credentials::new(
-//!         "username".to_string(),
-//!         "password".to_string(),
+//!         "username".to_owned(),
+//!         "password".to_owned(),
 //!     ))
 //!     // Configure expected authentication mechanism
 //!     .authentication(vec![Mechanism::Plain])
@@ -111,7 +111,7 @@
 //!     .body(String::from("Be happy!"))?;
 //!
 //! // Custom TLS configuration
-//! let tls = TlsParameters::builder("smtp.example.com".to_string())
+//! let tls = TlsParameters::builder("smtp.example.com".to_owned())
 //!     .dangerous_accept_invalid_certs(true)
 //!     .build()?;
 //!
@@ -140,7 +140,7 @@ pub use self::{
    error::Error,
    transport::{SmtpTransport, SmtpTransportBuilder},
 };
-#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+#[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
 use crate::transport::smtp::client::TlsParameters;
 use crate::transport::smtp::{
    authentication::{Credentials, Mechanism, DEFAULT_MECHANISMS},
@@ -200,7 +200,7 @@ struct SmtpInfo {
 impl Default for SmtpInfo {
    fn default() -> Self {
        Self {
-            server: "localhost".to_string(),
+            server: "localhost".to_owned(),
            port: SMTP_PORT,
            hello_name: ClientId::default(),
            credentials: None,
--- a/src/transport/smtp/pool/async_impl.rs
+++ b/src/transport/smtp/pool/async_impl.rs
@@ -203,7 +203,7 @@ impl<E: Executor> Debug for Pool<E> {
                &match self.connections.try_lock() {
                    Some(connections) => format!("{} connections", connections.len()),

-                    None => "LOCKED".to_string(),
+                    None => "LOCKED".to_owned(),
                },
            )
            .field("client", &self.client)
--- a/src/transport/smtp/pool/sync_impl.rs
+++ b/src/transport/smtp/pool/sync_impl.rs
@@ -186,8 +186,8 @@ impl Debug for Pool {
                &match self.connections.try_lock() {
                    Ok(connections) => format!("{} connections", connections.len()),

-                    Err(TryLockError::WouldBlock) => "LOCKED".to_string(),
-                    Err(TryLockError::Poisoned(_)) => "POISONED".to_string(),
+                    Err(TryLockError::WouldBlock) => "LOCKED".to_owned(),
+                    Err(TryLockError::Poisoned(_)) => "POISONED".to_owned(),
                },
            )
            .field("client", &self.client)
--- a/src/transport/smtp/response.rs
+++ b/src/transport/smtp/response.rs
@@ -151,7 +151,7 @@ impl FromStr for Response {
    fn from_str(s: &str) -> result::Result<Response, Error> {
        parse_response(s)
            .map(|(_, r)| r)
-            .map_err(|e| error::response(e.to_string()))
+            .map_err(|e| error::response(e.to_owned()))
    }
 }

@@ -329,10 +329,10 @@ mod test {
                    detail: Detail::Zero,
                },
                message: vec![
-                    "me".to_string(),
-                    "8BITMIME".to_string(),
-                    "SIZE 42".to_string(),
-                    "AUTH PLAIN CRAM-MD5".to_string(),
+                    "me".to_owned(),
+                    "8BITMIME".to_owned(),
+                    "SIZE 42".to_owned(),
+                    "AUTH PLAIN CRAM-MD5".to_owned(),
                ],
            }
        );
@@ -352,11 +352,7 @@ mod test {
                category: Category::MailSystem,
                detail: Detail::Zero,
            },
-            vec![
-                "me".to_string(),
-                "8BITMIME".to_string(),
-                "SIZE 42".to_string(),
-            ],
+            vec!["me".to_owned(), "8BITMIME".to_owned(), "SIZE 42".to_owned(),],
        )
        .is_positive());
        assert!(!Response::new(
@@ -365,11 +361,7 @@ mod test {
                category: Category::MailSystem,
                detail: Detail::Zero,
            },
-            vec![
-                "me".to_string(),
-                "8BITMIME".to_string(),
-                "SIZE 42".to_string(),
-            ],
+            vec!["me".to_owned(), "8BITMIME".to_owned(), "SIZE 42".to_owned(),],
        )
        .is_positive());
    }
@@ -382,11 +374,7 @@ mod test {
                category: Category::MailSystem,
                detail: Detail::One,
            },
-            vec![
-                "me".to_string(),
-                "8BITMIME".to_string(),
-                "SIZE 42".to_string(),
-            ],
+            vec!["me".to_owned(), "8BITMIME".to_owned(), "SIZE 42".to_owned(),],
        )
        .has_code(451));
        assert!(!Response::new(
@@ -395,11 +383,7 @@ mod test {
                category: Category::MailSystem,
                detail: Detail::One,
            },
-            vec![
-                "me".to_string(),
-                "8BITMIME".to_string(),
-                "SIZE 42".to_string(),
-            ],
+            vec!["me".to_owned(), "8BITMIME".to_owned(), "SIZE 42".to_owned(),],
        )
        .has_code(251));
    }
@@ -413,11 +397,7 @@ mod test {
                    category: Category::MailSystem,
                    detail: Detail::One,
                },
-                vec![
-                    "me".to_string(),
-                    "8BITMIME".to_string(),
-                    "SIZE 42".to_string(),
-                ],
+                vec!["me".to_owned(), "8BITMIME".to_owned(), "SIZE 42".to_owned(),],
            )
            .first_word(),
            Some("me")
@@ -430,9 +410,9 @@ mod test {
                    detail: Detail::One,
                },
                vec![
-                    "me mo".to_string(),
-                    "8BITMIME".to_string(),
-                    "SIZE 42".to_string(),
+                    "me mo".to_owned(),
+                    "8BITMIME".to_owned(),
+                    "SIZE 42".to_owned(),
                ],
            )
            .first_word(),
@@ -457,7 +437,7 @@ mod test {
                    category: Category::MailSystem,
                    detail: Detail::One,
                },
-                vec![" ".to_string()],
+                vec![" ".to_owned()],
            )
            .first_word(),
            None
@@ -469,7 +449,7 @@ mod test {
                    category: Category::MailSystem,
                    detail: Detail::One,
                },
-                vec!["  ".to_string()],
+                vec!["  ".to_owned()],
            )
            .first_word(),
            None
@@ -481,7 +461,7 @@ mod test {
                    category: Category::MailSystem,
                    detail: Detail::One,
                },
-                vec!["".to_string()],
+                vec!["".to_owned()],
            )
            .first_word(),
            None
@@ -494,7 +474,7 @@ mod test {
        let res = parse_response(raw_response);
        match res {
            Err(nom::Err::Incomplete(_)) => {}
-            _ => panic!("Expected incomplete response, got {:?}", res),
+            _ => panic!("Expected incomplete response, got {res:?}"),
        }
    }

@@ -507,11 +487,7 @@ mod test {
                    category: Category::MailSystem,
                    detail: Detail::One,
                },
-                vec![
-                    "me".to_string(),
-                    "8BITMIME".to_string(),
-                    "SIZE 42".to_string(),
-                ],
+                vec!["me".to_owned(), "8BITMIME".to_owned(), "SIZE 42".to_owned(),],
            )
            .first_line(),
            Some("me")
@@ -524,9 +500,9 @@ mod test {
                    detail: Detail::One,
                },
                vec![
-                    "me mo".to_string(),
-                    "8BITMIME".to_string(),
-                    "SIZE 42".to_string(),
+                    "me mo".to_owned(),
+                    "8BITMIME".to_owned(),
+                    "SIZE 42".to_owned(),
                ],
            )
            .first_line(),
@@ -551,7 +527,7 @@ mod test {
                    category: Category::MailSystem,
                    detail: Detail::One,
                },
-                vec![" ".to_string()],
+                vec![" ".to_owned()],
            )
            .first_line(),
            Some(" ")
@@ -563,7 +539,7 @@ mod test {
                    category: Category::MailSystem,
                    detail: Detail::One,
                },
-                vec!["  ".to_string()],
+                vec!["  ".to_owned()],
            )
            .first_line(),
            Some("  ")
@@ -575,7 +551,7 @@ mod test {
                    category: Category::MailSystem,
                    detail: Detail::One,
                },
-                vec!["".to_string()],
+                vec!["".to_owned()],
            )
            .first_line(),
            Some("")
--- a/src/transport/smtp/transport.rs
+++ b/src/transport/smtp/transport.rs
@@ -7,7 +7,7 @@ use super::pool::sync_impl::Pool;
 #[cfg(feature = "pool")]
 use super::PoolConfig;
 use super::{ClientId, Credentials, Error, Mechanism, Response, SmtpConnection, SmtpInfo};
-#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+#[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
 use super::{Tls, TlsParameters, SUBMISSIONS_PORT, SUBMISSION_PORT};
 use crate::{address::Envelope, Transport};

@@ -45,8 +45,11 @@ impl SmtpTransport {
    ///
    /// Creates an encrypted transport over submissions port, using the provided domain
    /// to validate TLS certificates.
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
    pub fn relay(relay: &str) -> Result<SmtpTransportBuilder, Error> {
        let tls_parameters = TlsParameters::new(relay.into())?;

@@ -66,8 +69,11 @@ impl SmtpTransport {
    ///
    /// An error is returned if the connection can't be upgraded. No credentials
    /// or emails will be sent to the server, protecting from downgrade attacks.
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
    pub fn starttls_relay(relay: &str) -> Result<SmtpTransportBuilder, Error> {
        let tls_parameters = TlsParameters::new(relay.into())?;

@@ -166,8 +172,11 @@ impl SmtpTransportBuilder {
    }

    /// Set the TLS settings to use
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-    #[cfg_attr(docsrs, doc(cfg(any(feature = "native-tls", feature = "rustls-tls"))))]
+    #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
+    #[cfg_attr(
+        docsrs,
+        doc(cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls")))
+    )]
    pub fn tls(mut self, tls: Tls) -> Self {
        self.info.tls = tls;
        self
@@ -210,7 +219,7 @@ impl SmtpClient {
    pub fn connection(&self) -> Result<SmtpConnection, Error> {
        #[allow(clippy::match_single_binding)]
        let tls_parameters = match self.info.tls {
-            #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+            #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
            Tls::Wrapper(ref tls_parameters) => Some(tls_parameters),
            _ => None,
        };
@@ -224,7 +233,7 @@ impl SmtpClient {
            None,
        )?;

-        #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+        #[cfg(any(feature = "native-tls", feature = "rustls-tls", feature = "boring-tls"))]
        match self.info.tls {
            Tls::Opportunistic(ref tls_parameters) => {
                if conn.can_starttls() {
--- a/src/transport/smtp/util.rs
+++ b/src/transport/smtp/util.rs
@@ -41,7 +41,7 @@ mod tests {
        ]
        .iter()
        {
-            assert_eq!(format!("{}", XText(input)), (*expect).to_string());
+            assert_eq!(format!("{}", XText(input)), (*expect).to_owned());
        }
    }
 }
--- a/tests/transport_file.rs
+++ b/tests/transport_file.rs
@@ -33,7 +33,7 @@ mod sync {
        let result = sender.send(&email);
        let id = result.unwrap();

-        let eml_file = temp_dir().join(format!("{}.eml", id));
+        let eml_file = temp_dir().join(format!("{id}.eml"));
        let eml = read_to_string(&eml_file).unwrap();

        assert_eq!(
@@ -68,10 +68,10 @@ mod sync {
        let result = sender.send(&email);
        let id = result.unwrap();

-        let eml_file = temp_dir().join(format!("{}.eml", id));
+        let eml_file = temp_dir().join(format!("{id}.eml"));
        let eml = read_to_string(&eml_file).unwrap();

-        let json_file = temp_dir().join(format!("{}.json", id));
+        let json_file = temp_dir().join(format!("{id}.json"));
        let json = read_to_string(&json_file).unwrap();

        assert_eq!(
@@ -131,7 +131,7 @@ mod tokio_1 {
        let result = sender.send(email).await;
        let id = result.unwrap();

-        let eml_file = temp_dir().join(format!("{}.eml", id));
+        let eml_file = temp_dir().join(format!("{id}.eml"));
        let eml = read_to_string(&eml_file).unwrap();

        assert_eq!(
@@ -182,7 +182,7 @@ mod asyncstd_1 {
        let result = sender.send(email).await;
        let id = result.unwrap();

-        let eml_file = temp_dir().join(format!("{}.eml", id));
+        let eml_file = temp_dir().join(format!("{id}.eml"));
        let eml = read_to_string(&eml_file).unwrap();

        assert_eq!(
--- a/tests/transport_sendmail.rs
+++ b/tests/transport_sendmail.rs
@@ -15,7 +15,7 @@ mod sync {
            .unwrap();

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

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

        let result = sender.send(email).await;
-        println!("{:?}", result);
+        println!("{result:?}");
        assert!(result.is_ok());
    }
 }
Author	SHA1	Message	Date
Paolo Barbolini	4fb67a7da1	Prepare 0.10.3 (#860 )	2023-02-20 11:56:28 +01:00
Paolo Barbolini	9041f210f4	Add Content-Type to all examples sending a basic text/plain message (#859 )	2023-02-14 17:54:05 +00:00
Paolo Barbolini	77b7d40fb8	mailbox: replace serialize_str(&self.to_string()) with collect_str(self) (#858 )	2023-02-14 18:35:29 +01:00
Paolo Barbolini	2b6d457f85	clippy: deny str_to_string and empty_structs_with_brackets (#857 )	2023-02-14 18:33:10 +01:00
Stéphan Kochen	952c1b39df	Add support for rustls-native-certs (#843 )	2023-02-14 18:11:42 +01:00
Paolo Barbolini	7ecb87f9fd	Prepare 0.10.2 (#853 )	2023-01-29 14:58:41 +01:00
Paolo Barbolini	fd700b1717	cargo: switch to crates.io release of email-encoding v0.2 (#854 )	2023-01-29 14:47:08 +01:00
Paolo Barbolini	f8f19d6af5	clippy: fix latest warnings (#855 )	2023-01-29 13:46:57 +00:00
Paolo Barbolini	cc25223914	Update rsa to v0.8 (#852 )	2023-01-24 10:26:25 +01:00
Paolo Barbolini	750573d38b	Update base64 to v0.21 (#851 )	2023-01-24 10:07:48 +01:00
finga	0734a96343	tracing: Write some logs when sending an email (#848 ) Write a trace message when sending an email. Further, write a debug message when using the sendmail transport method, containing which program is called. And write a debug message containing the target file name when the file transport method is used. This should help improve #556 a tiny bit. Co-authored-by: finga <finga@onders.org>	2023-01-24 09:14:31 +01:00
Christian Mandery	3c2f996856	Fix broken URL for IETF user-agent draft (#849 )	2023-01-16 11:34:30 +00:00
lfuerderer	9cae29dd07	Add Content-Type header in documentation example (#841 ) * Add Content-Type header in documentation example In the example showing how to build a message from a pure string, set the Content-Type to text/plain explicitly. This header constant also includes the phrase charset=utf-8 so that non-ascii characters will be displayed correctly. * cargo fmt * Fix generated email example Co-authored-by: Paolo Barbolini <paolo.barbolini@m4ss.net>	2022-12-16 22:04:29 +00:00
Paolo Barbolini	e1a146c8f8	cargo: bump base64 to 0.20 (#840 )	2022-12-10 22:29:01 +00:00
Paolo Barbolini	840a19784a	cargo: require quoted_printable ^0.4.6 (#837 )	2022-12-07 15:37:38 +00:00
Paolo Barbolini	5a61ba36b5	ci: bump nightly used for rustfmt (#817 )	2022-11-12 19:51:24 +01:00
Paolo Barbolini	dbf0e53c31	Fix latest clippy warnings (#830 )	2022-11-12 17:54:20 +00:00
Paolo Barbolini	c914a07379	Update dependencies (#829 )	2022-11-12 17:45:19 +00:00
Paolo Barbolini	2c4fa39523	Use cargo weak dependency features to reduce tokio features (#785 )	2022-11-12 17:34:55 +00:00
Clément DOUIN	28f0af16be	Mailbox displays wrongly when containing a comma and a non-ascii char in its name (#827 )	2022-11-12 17:23:06 +00:00
Paolo Barbolini	f0614be555	Bump MSRV to 1.60 (#828 )	2022-11-12 17:13:14 +00:00
André Cruz	a3fcdf263d	fix(transport): return whole smtp error string (#821 ) We were only returning the first line of the error message, but that may not be enough to get the whole context of the error. Since we have already parsed the response, just return the whole error to the user. Related to #694	2022-09-22 16:30:04 +02:00
Paolo Barbolini	d4da2e1f14	ci: switch to Swatinem/rust-cache@v2 (#819 )	2022-09-10 13:19:49 +02:00
Paolo Barbolini	5655958288	clippy: fix latest warning (#818 )	2022-09-10 10:59:49 +00:00
Paolo Barbolini	11b4acf0cd	Improve header encoding and wrapping (#811 ) Also cleans up the encoder a lot, removing some complicated logic introduced by the initial round of implementation	2022-09-10 12:40:00 +02:00
Paolo Barbolini	b3b5df285a	Bump idna to 0.3 (#816 )	2022-09-09 07:38:59 +00:00
Tom Dryer	3c051d52e7	Remove dependency on regex crate (#815 ) Replace implementation of DKIM body canonicalization to remove dependency on the `regex` crate. Fixes #768.	2022-08-22 09:44:10 +02:00
André Cruz	d6128a146e	use a generic transport trait for async connections (#805 ) Rely on a generic transport trait and allow passing in one. This will enable use cases where we don't have a real Tokio TCP stream, or have to bind a specific source address before establishing the connection.	2022-07-27 09:40:13 +02:00
André Cruz	fab6680150	Fix clippy warnings (#807 ) Depending on the features chosen these attributes were left unused.	2022-07-25 18:00:17 +02:00
Paolo Barbolini	0c9fc6cb71	Prepare 0.10.1 (#804 )	2022-07-20 10:44:55 +02:00
Paolo Barbolini	2228cbdf93	Fix SMTP dot stuffing (#803 )	2022-07-19 23:20:44 +02:00
André Cruz	17c95b0fa8	Ensure connection is closed on abort (#801 ) When aborting a connection, ensure the underlying stream is closed before we return.	2022-07-19 21:13:51 +02:00
Paolo Barbolini	62725af00a	Improve `TlsVersion` docs and remember to re-export it (#800 )	2022-07-18 07:40:46 +00:00
André Cruz	758bf1a4a7	Configurable minimum TLS version (#799 ) Added support for configuring the minimum accepted TLS version. The supported versions differ between TLS toolkits.	2022-07-17 13:11:14 +02:00
Paolo Barbolini	054c79f914	Document the boring-tls features in lib.rs (#798 )	2022-07-16 09:45:44 +00:00
André Cruz	985fa7edc4	Add support for boring TLS (#797 ) In contexts where FIPS certification is mandatory, having the ability to use the certified boring TLS library is sometimes necessary. Added initial support for it, only one TLS toolkit can be enabled at one time.	2022-07-16 11:28:14 +02:00