Merge pull request #277 from amousset/v0.8.x

Prepare 0.8.2

.appveyor.yml

@@ -0,0 +1,14 @@
+environment:
+  matrix:
+    - TARGET: x86_64-pc-windows-msvc
+install:
+  - curl -sSf -o rustup-init.exe https://win.rustup.rs/
+  - rustup-init.exe -y --default-host %TARGET%
+  - set PATH=%PATH%;C:\Users\appveyor\.cargo\bin
+  - rustc -vV
+  - cargo -vV
+build: false
+test_script:
+  - cargo build --verbose --manifest-path lettre/Cargo.toml
+  - cargo test --verbose --manifest-path lettre_email/Cargo.toml
+  

.build-scripts/codecov.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+set -xe
+
+wget https://github.com/SimonKagstrom/kcov/archive/master.tar.gz
+tar xzf master.tar.gz
+cd kcov-master
+mkdir build
+cd build
+cmake ..
+make
+make install DESTDIR=../../kcov-build
+cd ../..
+rm -rf kcov-master
+for file in target/debug/lettre*[^\.d]; do
+  mkdir -p "target/cov/$(basename $file)"
+  ./kcov-build/usr/local/bin/kcov --exclude-pattern=/.cargo,/usr/lib --verify "target/cov/$(basename $file)" "$file"
+done
+bash <(curl -s https://codecov.io/bash)
+echo "Uploaded code coverage"

.build-scripts/site-upload.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+set -xe
+
+cd website
+make clean && make
+echo "lettre.at" > _book/CNAME
+sudo pip install ghp-import
+ghp-import -n _book
+git push -f https://${GH_TOKEN}@github.com/${TRAVIS_REPO_SLUG}.git gh-pages

.github/FUNDING.yml

@@ -1 +0,0 @@
-liberapay: amousset

.github/ISSUE_TEMPLATE/Bug_report.md

@@ -1,21 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Code allowing to reproduce the bug.
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Environment (please complete the following information):**
-- Lettre version
-- OS
-
-**Additional context**
-Add any other context about the problem here.

.github/ISSUE_TEMPLATE/Feature_request.md

@@ -1,17 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/workflows/audit.yml

@@ -1,12 +0,0 @@
-name: Security audit
-on:
-  schedule:
-    - cron: '0 0 * * *'
-jobs:
-  audit:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/audit-check@v1
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/test.yml

@@ -1,144 +0,0 @@
-name: CI
-
-on:
-  pull_request:
-  push:
-    branches:
-      - master
-
-env:
-  RUST_BACKTRACE: full
-
-jobs:
-  rustfmt:
-    name: rustfmt / stable
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Install rust
-        run: |
-          rustup update --no-self-update stable
-          rustup component add rustfmt
-
-      - name: cargo fmt
-        run: cargo fmt --all -- --check
-
-  clippy:
-    name: clippy / stable
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Install rust
-        run: |
-          rustup update --no-self-update stable
-          rustup component add clippy
-
-      - name: Run clippy
-        run: cargo clippy --all-features --all-targets -- -D warnings
-
-  check:
-    name: check / stable
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Setup cache
-        uses: actions/cache@v2
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-          key: ${{ runner.os }}-cargo-check
-
-      - name: Install rust
-        run: rustup update --no-self-update stable
-      
-      - name: Install cargo hack
-        run: cargo install cargo-hack --debug
-
-      - name: Check with cargo hack
-        run: cargo hack check --feature-powerset --depth 3
-
-  test:
-    name: test / ${{ matrix.name }}
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        include:
-          - name: stable
-            rust: stable
-          - name: beta
-            rust: beta
-          - name: 1.46.0
-            rust: 1.46.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: Install postfix  
-        run: |
-          DEBIAN_FRONTEND=noninteractive sudo apt-get update
-          DEBIAN_FRONTEND=noninteractive sudo apt-get -y install postfix
-
-      - name: Run SMTP server
-        run: smtp-sink 2525 1000&
-
-      - name: Test with no default features
-        run: cargo test --no-default-features
-
-      - name: Test with default features
-        run: cargo test
-
-      - name: Test with all features
-        run: cargo test --all-features
-  
-#  coverage:
-#    name: Coverage
-#    runs-on: ubuntu-latest
-#    steps:
-#      - uses: actions/checkout@v2
-#      - uses: actions-rs/toolchain@v1
-#        with:
-#          toolchain: nightly
-#          override: true
-#      - run: sudo DEBIAN_FRONTEND=noninteractive apt-get -y install postfix
-#      - run: smtp-sink 2525 1000&
-#      - uses: actions-rs/cargo@v1
-#        with:
-#          command: test
-#          args: --no-fail-fast
-#        env:
-#          CARGO_INCREMENTAL: "0"
-#          RUSTFLAGS: "-Zprofile -Ccodegen-units=1 -Cinline-threshold=0 -Clink-dead-code -Coverflow-checks=off -Zno-landing-pads"
-#      - id: coverage
-#        uses: actions-rs/grcov@v0.1
-#      - name: Coveralls upload
-#        uses: coverallsapp/github-action@master
-#        with:
-#          github-token: ${{ secrets.GITHUB_TOKEN }}
-#          path-to-lcov: ${{ steps.coverage.outputs.report }}

.gitignore

@@ -1,7 +1,6 @@
 .vscode/
 .project/
 .idea/
-lettre.sublime-*
 lettre.iml
 target/
 /Cargo.lock

.travis.yml

@@ -0,0 +1,31 @@
+language: rust
+rust:
+- stable
+- beta
+- nightly
+- 1.20.0
+matrix:
+  allow_failures:
+  - rust: nightly
+sudo: required
+addons:
+  apt:
+    packages:
+    - postfix
+    - libcurl4-openssl-dev
+    - libelf-dev
+    - libdw-dev
+    - cmake
+    - gcc
+    - binutils-dev
+    - libiberty-dev
+    - npm
+before_script:
+- smtp-sink 2525 1000&
+- sudo chgrp -R postdrop /var/spool/postfix/maildrop
+- sudo npm set strict-ssl false && sudo npm install -g gitbook-cli
+script:
+- cargo test --verbose --all
+after_success:
+- ./.build-scripts/codecov.sh
+- '[ "$TRAVIS_BRANCH" = "v0.8.x" ] && [ $TRAVIS_PULL_REQUEST = false ] && ./.build-scripts/site-upload.sh'

CHANGELOG.md

@@ -1,107 +1,3 @@
-<a name="v0.10.0"></a>
-### v0.10.0 (unreleased)
-
-#### Upgrade notes
-
-Several breaking changes were made between 0.9 and 0.10, but changes should be straightforward:
-
-* MSRV is now 1.46
-* The `lettre_email` crate has been merged into `lettre`. To migrate, replace `lettre_email` with `lettre::message`
-  and make sure to enable the `builder` feature (it's enabled by default).
-* `SendableEmail` has been renamed to `Email` and `EmailBuilder::build()` produces it directly. To migrate,
-  rename `SendableEmail` to `Email`.
-* The `serde-impls` feature has been renamed to `serde`. To migrate, rename the feature.
-
-#### Features
-
-* Add `tokio` 1 support
-* Add `rustls` support
-* Add `async-std` support. NOTE: native-tls isn't supported when using async-std for the smtp transport.
-* Allow enabling multiple SMTP authentication mechanisms
-* Allow providing a custom message id
-* Allow sending raw emails
-
-#### Breaking Changes
-
-* Merge `lettre_email` into `lettre`
-* Merge `Email` and `SendableEmail` into `lettre::message::Email`
-* SmtpTransport is now an high level SMTP client. It provides connection pooling and shortcuts for building clients using commonly desired values
-* Refactor `TlsParameters` implementation to not expose the internal TLS library
-* `FileTransport` writes emails into `.eml` instead of `.json`
-* When the hostname feature is disabled or hostname cannot be fetched, `127.0.0.1` is used instead of `localhost` as EHLO parameter (for better RFC compliance and mail server compatibility)
-* The `new` method of `ClientId` is deprecated
-* Rename `serde-impls` feature to `serde`
-
-
-#### Bug Fixes
-
-* Fix argument injection in `SendmailTransport` (see [RUSTSEC-2020-0069](https://github.com/RustSec/advisory-db/blob/master/crates/lettre/RUSTSEC-2020-0069.md))
-* Correctly encode header values containing non-ASCII characters
-* Timeout bug causing infinite hang
-* Fix doc tests in website
-* Fix docs for `domain` field
-
-#### Misc
-
-* Improve documentation, examples and tests
-* Replace `line-wrap`, `email`, `bufstream` with our own implementations
-* Remove `bytes`
-* Remove `time`
-* Remove `fast_chemail`
-* Update `base64` to 0.13
-* Update `hostname` to 0.3
-* Update to `nom` 6
-* Replace `log` with `tracing`
-* Move CI to Github Actions
-* Use criterion for benchmarks
-
-<a name="v0.9.2"></a>
-### v0.9.2 (2019-06-11)
-
-#### Bug Fixes
-
-* **email:**
-  * Fix compilation with Rust 1.36+ ([393ef8d](https://github.com/lettre/lettre/commit/393ef8dcd1b1c6a6119d0666d5f09b12f50f6b4b))
-
-<a name="v0.9.1"></a>
-### v0.9.1 (2019-05-05)
-
-#### Features
-
-* **email:**
-  * Re-export mime crate ([a0c8fb9](https://github.com/lettre/lettre/commit/a0c8fb9))
-
-<a name="v0.9.0"></a>
-### v0.9.0 (2019-03-17)
-
-#### Bug Fixes
-
-* **email:**
-  * Inserting 'from' from envelope into message headers ([058fa69](https://github.com/lettre/lettre/commit/058fa69))
-  * Do not include Bcc addresses in headers ([ee31bbe](https://github.com/lettre/lettre/commit/ee31bbe))
-
-* **transport:**
-  * Write timeout is not set in smtp transport ([d71b560](https://github.com/lettre/lettre/commit/d71b560))
-  * Client::read_response infinite loop ([72f3cd8](https://github.com/lettre/lettre/commit/72f3cd8))
-
-#### Features
-
-* **all:**
-  * Update dependencies
-  * Start using the failure crate for errors ([c10fe3d](https://github.com/lettre/lettre/commit/c10fe3d))
-
-* **transport:**
-  * Remove TLS 1.1 in accepted protocols by default (only allow TLS 1.2) ([4b48bdb](https://github.com/lettre/lettre/commit/4b48bdb))
-  * Initial support for XOAUTH2 ([ed7c164](https://github.com/lettre/lettre/commit/ed7c164))
-  * Remove support for CRAM-MD5 ([bc09aa2](https://github.com/lettre/lettre/commit/bc09aa2))
-  * SMTP connection pool implementation with r2d2 ([434654e](https://github.com/lettre/lettre/commit/434654e))
-  * Use md-5 and hmac instead of rust-crypto ([e7e0f34](https://github.com/lettre/lettre/commit/e7e0f34))
-  * Gmail transport simple example ([a8d8e2a](https://github.com/lettre/lettre/commit/a8d8e2a))
-
-* **email:**
-  * Add In-Reply-To and References headers ([fc91bb6](https://github.com/lettre/lettre/commit/fc91bb6))
-  * Remove non-chaining builder methods ([1baf8a9](https://github.com/lettre/lettre/commit/1baf8a9))
-
 <a name="v0.8.2"></a>
 ### v0.8.2 (2018-05-03)
 

CODE_OF_CONDUCT.md

@@ -34,13 +34,13 @@ This Code of Conduct applies both within project spaces and in public spaces whe
 
 ## Enforcement
 
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at contact@lettre.rs. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at contact@lettre.at. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
 
 Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
 
 ## Attribution
 
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [https://www.contributor-covenant.org/version/1/4][version]
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
 
-[homepage]: https://www.contributor-covenant.org
-[version]: https://www.contributor-covenant.org/version/1/4/
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

CONTRIBUTING.md

@@ -33,11 +33,3 @@ Any line of the commit message cannot be longer 72 characters.
     all
 
 The body explains the change, and the footer contains relevant changelog notes and references to fixed issues.
-
-### Release process
-
-Releases are made using `cargo-release`:
-
-```bash
-cargo release --dry-run 0.10.0 --prev-tag-name v0.9.2 -v
-```

Cargo.toml

@@ -1,140 +1,5 @@
-[package]
-name = "lettre"
-# remember to update html_root_url and README.md (Cargo.toml example and deps.rs badge)
-version = "0.10.0-rc.1"
-description = "Email client"
-readme = "README.md"
-homepage = "https://lettre.rs"
-repository = "https://github.com/lettre/lettre"
-license = "MIT"
-authors = ["Alexis Mousset <contact@amousset.me>", "Paolo Barbolini <paolo@paolo565.org>"]
-categories = ["email", "network-programming"]
-keywords = ["email", "smtp", "mailer", "message", "sendmail"]
-edition = "2018"
-
-[badges]
-is-it-maintained-issue-resolution = { repository = "lettre/lettre" }
-is-it-maintained-open-issues = { repository = "lettre/lettre" }
-maintenance = { status = "actively-developed" }
-
-[dependencies]
-idna = "0.2"
-tracing = { version = "0.1.16", default-features = false, features = ["std"], optional = true } # feature
-
-# builder
-httpdate = { version = "1", optional = true }
-mime = { version = "0.3.4", optional = true }
-fastrand = { version = "1.4", optional = true }
-quoted_printable = { version = "0.4", optional = true }
-base64 = { version = "0.13", optional = true }
-once_cell = "1"
-regex = { version = "1", default-features = false, features = ["std", "unicode-case"] }
-
-# file transport
-uuid = { version = "0.8", features = ["v4"], optional = true }
-serde = { version = "1", optional = true, features = ["derive"] }
-serde_json = { version = "1", optional = true }
-
-# smtp
-nom = { version = "6", default-features = false, features = ["alloc", "std"], optional = true }
-r2d2 = { version = "0.8", optional = true } # feature
-hostname = { version = "0.3", optional = true } # feature
-
-## tls
-native-tls = { version = "0.2", optional = true } # feature
-rustls = { version = "0.19", features = ["dangerous_configuration"], optional = true }
-webpki = { version = "0.21", optional = true }
-webpki-roots = { version = "0.21", optional = true }
-
-# async
-futures-io = { version = "0.3.7", optional = true }
-futures-util = { version = "0.3.7", default-features = false, features = ["io"], optional = true }
-async-trait = { version = "0.1", optional = true }
-
-## async-std
-async-std = { version = "1.8", optional = true, features = ["unstable"] }
-#async-native-tls = { version = "0.3.3", optional = true }
-async-rustls = { version = "0.2", optional = true }
-
-## tokio
-tokio1_crate = { package = "tokio", version = "1", features = ["fs", "process", "net", "io-util"], optional = true }
-tokio1_native_tls_crate = { package = "tokio-native-tls", version = "0.3", optional = true }
-tokio1_rustls = { package = "tokio-rustls", version = "0.22", optional = true }
-
-[dev-dependencies]
-criterion = "0.3"
-tracing-subscriber = "0.2.10"
-glob = "0.3"
-walkdir = "2"
-tokio1_crate = { package = "tokio", version = "1", features = ["macros", "rt-multi-thread"] }
-async-std = { version = "1.8", features = ["attributes"] }
-serde_json = "1"
-maud = "0.22.1"
-
-[[bench]]
-harness = false
-name = "transport_smtp"
-
-[features]
-default = ["smtp-transport", "native-tls", "hostname", "r2d2", "builder"]
-builder = ["httpdate", "mime", "base64", "fastrand", "quoted_printable"]
-
-# transports
-file-transport = ["uuid"]
-file-transport-envelope = ["serde", "serde_json", "file-transport"]
-sendmail-transport = []
-smtp-transport = ["base64", "nom"]
-
-rustls-tls = ["webpki", "webpki-roots", "rustls"]
-
-# async
-async-std1 = ["async-std", "async-trait", "futures-io", "futures-util"]
-#async-std1-native-tls = ["async-std1", "native-tls", "async-native-tls"]
-async-std1-rustls-tls = ["async-std1", "rustls-tls", "async-rustls"]
-tokio1 = ["tokio1_crate", "async-trait", "futures-io", "futures-util"]
-tokio1-native-tls = ["tokio1", "native-tls", "tokio1_native_tls_crate"]
-tokio1-rustls-tls = ["tokio1", "rustls-tls", "tokio1_rustls"]
-
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = ["--cfg", "docsrs"]
-
-[[example]]
-name = "basic_html"
-required-features = ["file-transport", "builder"]
-
-[[example]]
-name = "maud_html"
-required-features = ["file-transport", "builder"]
-
-[[example]]
-name = "smtp"
-required-features = ["smtp-transport", "builder"]
-
-[[example]]
-name = "smtp_tls"
-required-features = ["smtp-transport", "native-tls", "builder"]
-
-[[example]]
-name = "smtp_starttls"
-required-features = ["smtp-transport", "native-tls", "builder"]
-
-[[example]]
-name = "smtp_selfsigned"
-required-features = ["smtp-transport", "native-tls", "builder"]
-
-[[example]]
-name = "tokio1_smtp_tls"
-required-features = ["smtp-transport", "tokio1", "tokio1-native-tls", "builder"]
-
-[[example]]
-name = "tokio1_smtp_starttls"
-required-features = ["smtp-transport", "tokio1", "tokio1-native-tls", "builder"]
-
-[[example]]
-name = "asyncstd1_smtp_tls"
-required-features = ["smtp-transport", "async-std1", "async-std1-rustls-tls", "builder"]
-
-[[example]]
-name = "asyncstd1_smtp_starttls"
-required-features = ["smtp-transport", "async-std1", "async-std1-rustls-tls", "builder"]
+[workspace]
+members = [
+    "lettre",
+    "lettre_email",
+]

LICENSE

@@ -1,6 +1,4 @@
-Copyright (c) 2014-2020 Alexis Mousset <contact@amousset.me>
-Copyright (c) 2019-2020 Paolo Barbolini <paolo@paolo565.org>
-Copyright (c) 2018 K. <kayo@illumium.org>
+Copyright (c) 2014-2018 Alexis Mousset
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated

README.md

@@ -1,51 +1,25 @@
-<h1 align="center">lettre</h1>
-<div align="center">
- <strong>
-   A mailer library for Rust
- </strong>
-</div>
+# lettre
 
-<br />
+**Lettre is a mailer library for Rust.**
 
-<div align="center">
-  <a href="https://docs.rs/lettre">
-    <img src="https://docs.rs/lettre/badge.svg"
-      alt="docs" />
-  </a>
-  <a href="https://crates.io/crates/lettre">
-    <img src="https://img.shields.io/crates/d/lettre.svg"
-      alt="downloads" />
-  </a>
-  <br />
-  <a href="https://gitter.im/lettre/lettre">
-    <img src="https://badges.gitter.im/lettre/lettre.svg"
-      alt="chat on gitter" />
-  </a>
-  <a href="https://lettre.rs">
-    <img src="https://img.shields.io/badge/visit-website-blueviolet"
-      alt="website" />
-  </a>
-</div>
+[![Build Status](https://travis-ci.org/lettre/lettre.svg?branch=master)](https://travis-ci.org/lettre/lettre)
+[![Build status](https://ci.appveyor.com/api/projects/status/mpwglemugjtkps2d/branch/master?svg=true)](https://ci.appveyor.com/project/amousset/lettre/branch/master)
+[![codecov](https://codecov.io/gh/lettre/lettre/branch/master/graph/badge.svg)](https://codecov.io/gh/lettre/lettre)
 
-<div align="center">
-  <a href="https://deps.rs/crate/lettre/0.10.0-rc.1">
-    <img src="https://deps.rs/crate/lettre/0.10.0-rc.1/status.svg"
-      alt="dependency status" />
-  </a>
-</div>
+[![Crate](https://img.shields.io/crates/v/lettre.svg)](https://crates.io/crates/lettre)
+[![Docs](https://docs.rs/lettre/badge.svg)](https://docs.rs/lettre/)
+[![Required Rust version](https://img.shields.io/badge/rustc-1.20-green.svg)]()
+[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
 
----
+[![Gitter](https://badges.gitter.im/lettre/lettre.svg)](https://gitter.im/lettre/lettre?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+[![Average time to resolve an issue](http://isitmaintained.com/badge/resolution/lettre/lettre.svg)](http://isitmaintained.com/project/lettre/lettre "Average time to resolve an issue")
+[![Percentage of issues still open](http://isitmaintained.com/badge/open/lettre/lettre.svg)](http://isitmaintained.com/project/lettre/lettre "Percentage of issues still open")
 
-**NOTE**: this readme refers to the 0.10 version of lettre, which is
-in release candidate state. Use the [`v0.9.x`](https://github.com/lettre/lettre/tree/v0.9.x)
-branch for the previous stable release.
+Useful links:
 
-0.10 is already widely used and is already thought to be more reliable than 0.9, so it should generally be used
-for new projects.
-
-We'd love to hear your feedback about 0.10 design and APIs before final release!
-Start a [discussion](https://github.com/lettre/lettre/discussions) in the repository, whether for
-feedback or if you need help or advice using or upgrading lettre 0.10.
+* [User documentation](http://lettre.at/)
+* [API documentation](https://docs.rs/lettre/)
+* [Changelog](https://github.com/lettre/lettre/blob/master/CHANGELOG.md)
 
 ---
 
@@ -57,47 +31,52 @@ Lettre provides the following features:
 * Unicode support (for email content and addresses)
 * Secure delivery with SMTP using encryption and authentication
 * Easy email builders
-* Async support
-
-Lettre does not provide (for now):
-
-* Email parsing
 
 ## Example
 
-This library requires Rust 1.46 or newer.
+This library requires Rust 1.20 or newer.
 To use this library, add the following to your `Cargo.toml`:
 
-
 ```toml
 [dependencies]
-lettre = "0.10.0-rc.1"
+lettre = "0.8"
+lettre_email = "0.8"
 ```
 
 ```rust,no_run
-use lettre::transport::smtp::authentication::Credentials;
-use lettre::{Message, SmtpTransport, Transport};
+extern crate lettre;
+extern crate lettre_email;
+extern crate mime;
 
-let email = Message::builder()
-    .from("NoBody <nobody@domain.tld>".parse().unwrap())
-    .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-    .to("Hei <hei@domain.tld>".parse().unwrap())
-    .subject("Happy new year")
-    .body(String::from("Be happy!"))
-    .unwrap();
+use lettre::{EmailTransport, SmtpTransport};
+use lettre_email::EmailBuilder;
+use std::path::Path;
 
-let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
+fn main() {
+    let email = EmailBuilder::new()
+        // Addresses can be specified by the tuple (email, alias)
+        .to(("user@example.org", "Firstname Lastname"))
+        // ... or by an address only
+        .from("user@example.com")
+        .subject("Hi, Hello world")
+        .text("Hello world.")
+        .attachment(Path::new("Cargo.toml"), None, &mime::TEXT_PLAIN).unwrap()
+        .build()
+        .unwrap();
 
-// Open a remote connection to gmail
-let mailer = SmtpTransport::relay("smtp.gmail.com")
-    .unwrap()
-    .credentials(creds)
-    .build();
+    // Open a local connection on port 25
+    let mut mailer = SmtpTransport::builder_unencrypted_localhost().unwrap()
+                                                                   .build();
+    // Send the email
+    let result = mailer.send(&email);
 
-// Send the email
-match mailer.send(&email) {
-    Ok(_) => println!("Email sent successfully!"),
-    Err(e) => panic!("Could not send email: {:?}", e),
+    if result.is_ok() {
+        println!("Email sent");
+    } else {
+        println!("Could not send email: {:?}", result);
+    }
+
+    assert!(result.is_ok());
 }
 ```
 
@@ -105,8 +84,6 @@ match mailer.send(&email) {
 
 The `lettre` tests require an open mail server listening locally on port 2525 and the `sendmail` command.
 
-Alternatively only unit tests can be run by doing `cargo test --lib`.
-
 ## Code of conduct
 
 Anyone who interacts with Lettre in any space, including but not limited to
@@ -116,7 +93,4 @@ this GitHub repository, must follow our [code of conduct](https://github.com/let
 
 This program is distributed under the terms of the MIT license.
 
-The builder comes from [emailmessage-rs](https://github.com/katyo/emailmessage-rs) by
-Kayo, under MIT license.
-
 See [LICENSE](./LICENSE) for details.

SECURITY.md

@@ -1,9 +0,0 @@
-## Report a security issue
-
-The lettre project team welcomes security reports and is committed to providing prompt attention to security issues.
-Security issues should be reported privately via [security@lettre.rs](mailto:security@lettre.rs). Security issues
-should not be reported via the public Github Issue tracker.
-
-## Security advisories
-
-Security issues will be announced via the [RustSec advisory database](https://github.com/RustSec/advisory-db).

benches/transport_smtp.rs

@@ -1,44 +0,0 @@
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use lettre::{Message, SmtpTransport, Transport};
-
-fn bench_simple_send(c: &mut Criterion) {
-    let sender = SmtpTransport::builder_dangerous("127.0.0.1")
-        .port(2525)
-        .build();
-
-    c.bench_function("send email", move |b| {
-        b.iter(|| {
-            let email = Message::builder()
-                .from("NoBody <nobody@domain.tld>".parse().unwrap())
-                .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-                .to("Hei <hei@domain.tld>".parse().unwrap())
-                .subject("Happy new year")
-                .body(String::from("Be happy!"))
-                .unwrap();
-            let result = black_box(sender.send(&email));
-            assert!(result.is_ok());
-        })
-    });
-}
-
-fn bench_reuse_send(c: &mut Criterion) {
-    let sender = SmtpTransport::builder_dangerous("127.0.0.1")
-        .port(2525)
-        .build();
-    c.bench_function("send email with connection reuse", move |b| {
-        b.iter(|| {
-            let email = Message::builder()
-                .from("NoBody <nobody@domain.tld>".parse().unwrap())
-                .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-                .to("Hei <hei@domain.tld>".parse().unwrap())
-                .subject("Happy new year")
-                .body(String::from("Be happy!"))
-                .unwrap();
-            let result = black_box(sender.send(&email));
-            assert!(result.is_ok());
-        })
-    });
-}
-
-criterion_group!(benches, bench_simple_send, bench_reuse_send);
-criterion_main!(benches);

examples/README.md

@@ -1,24 +0,0 @@
-# Lettre Examples
-
-This folder contains examples showing how to use lettre in your own projects.
-
-## Message builder examples
-
-- [basic_html.rs] - Create an HTML email.
-- [maud_html.rs] - Create an HTML email using a [maud](https://github.com/lambda-fairy/maud) template.
-
-## SMTP Examples
-
-- [smtp.rs] - Send an email using a local SMTP daemon on port 25 as a relay.
-- [smtp_tls.rs] - Send an email over SMTP encrypted with TLS and authenticating with username and password.
-- [smtp_starttls.rs] - Send an email over SMTP with STARTTLS and authenticating with username and password.
-- [smtp_selfsigned.rs] - Send an email over SMTP encrypted with TLS using a self-signed certificate and authenticating with username and password.
-- The [smtp_tls.rs] and [smtp_starttls.rs] examples also feature `async`hronous implementations powered by [Tokio](https://tokio.rs/).
-  These files are prefixed with `tokio1_` or `asyncstd1_`.
-
-[basic_html.rs]: ./basic_html.rs
-[maud_html.rs]: ./maud_html.rs
-[smtp.rs]: ./smtp.rs
-[smtp_tls.rs]: ./smtp_tls.rs
-[smtp_starttls.rs]: ./smtp_starttls.rs
-[smtp_selfsigned.rs]: ./smtp_selfsigned.rs

examples/asyncstd1_smtp_starttls.rs

@@ -1,32 +0,0 @@
-use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncStd1Executor,
-    AsyncTransport, Message,
-};
-
-#[async_std::main]
-async fn main() {
-    tracing_subscriber::fmt::init();
-
-    let email = Message::builder()
-        .from("NoBody <nobody@domain.tld>".parse().unwrap())
-        .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-        .to("Hei <hei@domain.tld>".parse().unwrap())
-        .subject("Happy new async year")
-        .body(String::from("Be happy with async!"))
-        .unwrap();
-
-    let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
-
-    // Open a remote connection to gmail using STARTTLS
-    let mailer: AsyncSmtpTransport<AsyncStd1Executor> =
-        AsyncSmtpTransport::<AsyncStd1Executor>::starttls_relay("smtp.gmail.com")
-            .unwrap()
-            .credentials(creds)
-            .build();
-
-    // Send the email
-    match mailer.send(email).await {
-        Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
-    }
-}

examples/asyncstd1_smtp_tls.rs

@@ -1,32 +0,0 @@
-use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncStd1Executor,
-    AsyncTransport, Message,
-};
-
-#[async_std::main]
-async fn main() {
-    tracing_subscriber::fmt::init();
-
-    let email = Message::builder()
-        .from("NoBody <nobody@domain.tld>".parse().unwrap())
-        .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-        .to("Hei <hei@domain.tld>".parse().unwrap())
-        .subject("Happy new async year")
-        .body(String::from("Be happy with async!"))
-        .unwrap();
-
-    let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
-
-    // Open a remote connection to gmail
-    let mailer: AsyncSmtpTransport<AsyncStd1Executor> =
-        AsyncSmtpTransport::<AsyncStd1Executor>::relay("smtp.gmail.com")
-            .unwrap()
-            .credentials(creds)
-            .build();
-
-    // Send the email
-    match mailer.send(email).await {
-        Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
-    }
-}

examples/basic_html.rs

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

examples/maud_html.rs

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

examples/smtp.rs

@@ -1,22 +0,0 @@
-use lettre::{Message, SmtpTransport, Transport};
-
-fn main() {
-    tracing_subscriber::fmt::init();
-
-    let email = Message::builder()
-        .from("NoBody <nobody@domain.tld>".parse().unwrap())
-        .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-        .to("Hei <hei@domain.tld>".parse().unwrap())
-        .subject("Happy new year")
-        .body(String::from("Be happy!"))
-        .unwrap();
-
-    // Open a local connection on port 25
-    let mailer = SmtpTransport::unencrypted_localhost();
-
-    // Send the email
-    match mailer.send(&email) {
-        Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
-    }
-}

examples/smtp_selfsigned.rs

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

examples/smtp_starttls.rs

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

examples/smtp_tls.rs

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

examples/tokio1_smtp_starttls.rs

@@ -1,37 +0,0 @@
-// This line is only to make it compile from lettre's examples folder,
-// since it uses Rust 2018 crate renaming to import tokio.
-// Won't be needed in user's code.
-use tokio1_crate as tokio;
-
-use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncTransport, Message,
-    Tokio1Executor,
-};
-
-#[tokio::main]
-async fn main() {
-    tracing_subscriber::fmt::init();
-
-    let email = Message::builder()
-        .from("NoBody <nobody@domain.tld>".parse().unwrap())
-        .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-        .to("Hei <hei@domain.tld>".parse().unwrap())
-        .subject("Happy new async year")
-        .body(String::from("Be happy with async!"))
-        .unwrap();
-
-    let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
-
-    // Open a remote connection to gmail using STARTTLS
-    let mailer: AsyncSmtpTransport<Tokio1Executor> =
-        AsyncSmtpTransport::<Tokio1Executor>::starttls_relay("smtp.gmail.com")
-            .unwrap()
-            .credentials(creds)
-            .build();
-
-    // Send the email
-    match mailer.send(email).await {
-        Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
-    }
-}

examples/tokio1_smtp_tls.rs

@@ -1,37 +0,0 @@
-// This line is only to make it compile from lettre's examples folder,
-// since it uses Rust 2018 crate renaming to import tokio.
-// Won't be needed in user's code.
-use tokio1_crate as tokio;
-
-use lettre::{
-    transport::smtp::authentication::Credentials, AsyncSmtpTransport, AsyncTransport, Message,
-    Tokio1Executor,
-};
-
-#[tokio::main]
-async fn main() {
-    tracing_subscriber::fmt::init();
-
-    let email = Message::builder()
-        .from("NoBody <nobody@domain.tld>".parse().unwrap())
-        .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-        .to("Hei <hei@domain.tld>".parse().unwrap())
-        .subject("Happy new async year")
-        .body(String::from("Be happy with async!"))
-        .unwrap();
-
-    let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
-
-    // Open a remote connection to gmail
-    let mailer: AsyncSmtpTransport<Tokio1Executor> =
-        AsyncSmtpTransport::<Tokio1Executor>::relay("smtp.gmail.com")
-            .unwrap()
-            .credentials(creds)
-            .build();
-
-    // Send the email
-    match mailer.send(email).await {
-        Ok(_) => println!("Email sent successfully!"),
-        Err(e) => panic!("Could not send email: {:?}", e),
-    }
-}

lettre/CHANGELOG.md

@@ -0,0 +1 @@
+../CHANGELOG.md

lettre/Cargo.toml

@@ -0,0 +1,50 @@
+[package]
+
+name = "lettre"
+version = "0.8.2" # remember to update html_root_url
+description = "Email client"
+readme = "README.md"
+homepage = "http://lettre.at"
+repository = "https://github.com/lettre/lettre"
+license = "MIT"
+authors = ["Alexis Mousset <contact@amousset.me>"]
+categories = ["email"]
+keywords = ["email", "smtp", "mailer"]
+
+[badges]
+travis-ci = { repository = "lettre/lettre" }
+appveyor = { repository = "lettre/lettre" }
+maintenance = { status = "actively-developed" }
+is-it-maintained-issue-resolution = { repository = "lettre/lettre" }
+is-it-maintained-open-issues = { repository = "lettre/lettre" }
+
+[dependencies]
+log = "^0.4"
+nom = { version = "^3.2", optional = true }
+bufstream = { version = "^0.1", optional = true }
+native-tls = { version = "^0.1", optional = true }
+base64 = { version = "^0.9", optional = true }
+hex = { version = "^0.3", optional = true }
+hostname = { version = "^0.1", optional = true }
+md-5 = { version = "^0.7", optional = true }
+hmac = { version = "^0.6", optional = true }
+serde = { version = "^1.0", optional = true }
+serde_json = { version = "^1.0", optional = true }
+serde_derive = { version = "^1.0", optional = true }
+
+[dev-dependencies]
+env_logger = "^0.5"
+glob = "0.2"
+
+[features]
+default = ["file-transport", "crammd5-auth", "smtp-transport", "sendmail-transport"]
+unstable = []
+serde-impls = ["serde", "serde_derive"]
+file-transport = ["serde-impls", "serde_json"]
+crammd5-auth = ["md-5", "hmac", "hex"]
+smtp-transport = ["bufstream", "native-tls", "base64", "nom", "hostname"]
+sendmail-transport = []
+
+[[example]]
+name = "smtp"
+required-features = ["smtp-transport"]

lettre/LICENSE

@@ -0,0 +1 @@
+../LICENSE

lettre/README.md

@@ -0,0 +1 @@
+../README.md

lettre/benches/transport_smtp.rs

@@ -0,0 +1,44 @@
+#![feature(test)]
+
+extern crate lettre;
+extern crate test;
+
+use lettre::{ClientSecurity, SmtpTransport};
+use lettre::{EmailAddress, EmailTransport, SimpleSendableEmail};
+use lettre::smtp::ConnectionReuseParameters;
+
+#[bench]
+fn bench_simple_send(b: &mut test::Bencher) {
+    let mut sender = SmtpTransport::builder("127.0.0.1:2525", ClientSecurity::None)
+        .unwrap()
+        .build();
+    b.iter(|| {
+        let email = SimpleSendableEmail::new(
+            EmailAddress::new("user@localhost".to_string()),
+            vec![EmailAddress::new("root@localhost".to_string())],
+            "id".to_string(),
+            "Hello world".to_string(),
+        );
+        let result = sender.send(&email);
+        assert!(result.is_ok());
+    });
+}
+
+#[bench]
+fn bench_reuse_send(b: &mut test::Bencher) {
+    let mut sender = SmtpTransport::builder("127.0.0.1:2525", ClientSecurity::None)
+        .unwrap()
+        .connection_reuse(ConnectionReuseParameters::ReuseUnlimited)
+        .build();
+    b.iter(|| {
+        let email = SimpleSendableEmail::new(
+            EmailAddress::new("user@localhost".to_string()),
+            vec![EmailAddress::new("root@localhost".to_string())],
+            "id".to_string(),
+            "Hello world".to_string(),
+        );
+        let result = sender.send(&email);
+        assert!(result.is_ok());
+    });
+    sender.close()
+}

lettre/examples/smtp.rs

@@ -0,0 +1,30 @@
+extern crate env_logger;
+extern crate lettre;
+
+use lettre::{EmailTransport, SimpleSendableEmail, SmtpTransport};
+
+fn main() {
+    env_logger::init();
+
+    let email = SimpleSendableEmail::new(
+        "user@localhost".to_string(),
+        &["root@localhost".to_string()],
+        "my-message-id".to_string(),
+        "Hello ß☺ example".to_string(),
+    ).unwrap();
+
+    // Open a local connection on port 25
+    let mut mailer = SmtpTransport::builder_unencrypted_localhost()
+        .unwrap()
+        .build();
+    // Send the email
+    let result = mailer.send(&email);
+
+    if result.is_ok() {
+        println!("Email sent");
+    } else {
+        println!("Could not send email: {:?}", result);
+    }
+
+    assert!(result.is_ok());
+}

lettre/src/file/error.rs

@@ -0,0 +1,63 @@
+//! Error and result type for file transport
+
+use self::Error::*;
+use serde_json;
+use std::error::Error as StdError;
+use std::fmt::{self, Display, Formatter};
+use std::io;
+
+/// An enum of all error kinds.
+#[derive(Debug)]
+pub enum Error {
+    /// Internal client error
+    Client(&'static str),
+    /// IO error
+    Io(io::Error),
+    /// JSON serialization error
+    JsonSerialization(serde_json::Error),
+}
+
+impl Display for Error {
+    fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {
+        fmt.write_str(self.description())
+    }
+}
+
+impl StdError for Error {
+    fn description(&self) -> &str {
+        match *self {
+            Client(err) => err,
+            Io(ref err) => err.description(),
+            JsonSerialization(ref err) => err.description(),
+        }
+    }
+
+    fn cause(&self) -> Option<&StdError> {
+        match *self {
+            Io(ref err) => Some(&*err),
+            JsonSerialization(ref err) => Some(&*err),
+            _ => None,
+        }
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(err: io::Error) -> Error {
+        Io(err)
+    }
+}
+
+impl From<serde_json::Error> for Error {
+    fn from(err: serde_json::Error) -> Error {
+        JsonSerialization(err)
+    }
+}
+
+impl From<&'static str> for Error {
+    fn from(string: &'static str) -> Error {
+        Client(string)
+    }
+}
+
+/// SMTP result type
+pub type FileResult = Result<(), Error>;

lettre/src/file/mod.rs

@@ -0,0 +1,54 @@
+//! The file transport writes the emails to the given directory. The name of the file will be
+//! `message_id.txt`.
+//! It can be useful for testing purposes, or if you want to keep track of sent messages.
+//!
+
+use EmailTransport;
+use SendableEmail;
+use SimpleSendableEmail;
+use file::error::FileResult;
+use serde_json;
+use std::fs::File;
+use std::io::Read;
+use std::io::prelude::*;
+use std::path::{Path, PathBuf};
+
+pub mod error;
+
+/// Writes the content and the envelope information to a file
+#[derive(Debug)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub struct FileEmailTransport {
+    path: PathBuf,
+}
+
+impl FileEmailTransport {
+    /// Creates a new transport to the given directory
+    pub fn new<P: AsRef<Path>>(path: P) -> FileEmailTransport {
+        let mut path_buf = PathBuf::new();
+        path_buf.push(path);
+        FileEmailTransport { path: path_buf }
+    }
+}
+
+impl<'a, T: Read + 'a> EmailTransport<'a, T, FileResult> for FileEmailTransport {
+    fn send<U: SendableEmail<'a, T> + 'a>(&mut self, email: &'a U) -> FileResult {
+        let mut file = self.path.clone();
+        file.push(format!("{}.txt", email.message_id()));
+
+        let mut f = File::create(file.as_path())?;
+
+        let mut message_content = String::new();
+        let _ = email.message().read_to_string(&mut message_content);
+
+        let simple_email = SimpleSendableEmail::new_with_envelope(
+            email.envelope().clone(),
+            email.message_id().to_string(),
+            message_content,
+        );
+
+        f.write_all(serde_json::to_string(&simple_email)?.as_bytes())?;
+
+        Ok(())
+    }
+}

lettre/src/lib.rs

@@ -0,0 +1,279 @@
+//! Lettre is a mailer written in Rust. It provides a simple email builder and several transports.
+//!
+//! This mailer contains the available transports for your emails. To be sendable, the
+//! emails have to implement `SendableEmail`.
+//!
+
+#![doc(html_root_url = "https://docs.rs/lettre/0.8.2")]
+#![deny(missing_docs, missing_debug_implementations, missing_copy_implementations, trivial_casts,
+        trivial_numeric_casts, unsafe_code, unstable_features, unused_import_braces,
+        unused_qualifications)]
+#[cfg(feature = "smtp-transport")]
+extern crate base64;
+#[cfg(feature = "smtp-transport")]
+extern crate bufstream;
+#[cfg(feature = "crammd5-auth")]
+extern crate hex;
+#[cfg(feature = "crammd5-auth")]
+extern crate hmac;
+#[cfg(feature = "smtp-transport")]
+extern crate hostname;
+#[macro_use]
+extern crate log;
+#[cfg(feature = "crammd5-auth")]
+extern crate md5;
+#[cfg(feature = "smtp-transport")]
+extern crate native_tls;
+#[cfg(feature = "smtp-transport")]
+#[macro_use]
+extern crate nom;
+#[cfg(feature = "serde-impls")]
+#[macro_use]
+extern crate serde_derive;
+#[cfg(feature = "file-transport")]
+extern crate serde_json;
+
+#[cfg(feature = "smtp-transport")]
+pub mod smtp;
+#[cfg(feature = "sendmail-transport")]
+pub mod sendmail;
+pub mod stub;
+#[cfg(feature = "file-transport")]
+pub mod file;
+
+#[cfg(feature = "file-transport")]
+pub use file::FileEmailTransport;
+#[cfg(feature = "sendmail-transport")]
+pub use sendmail::SendmailTransport;
+#[cfg(feature = "smtp-transport")]
+pub use smtp::{ClientSecurity, SmtpTransport};
+#[cfg(feature = "smtp-transport")]
+pub use smtp::client::net::ClientTlsParameters;
+use std::fmt::{self, Display, Formatter};
+use std::io::Read;
+use std::error::Error as StdError;
+use std::str::FromStr;
+
+/// Error type for email content
+#[derive(Debug, Clone, Copy)]
+pub enum Error {
+    /// Missing from in envelope
+    MissingFrom,
+    /// Missing to in envelope
+    MissingTo,
+    /// Invalid email
+    InvalidEmailAddress,
+}
+
+impl StdError for Error {
+    fn description(&self) -> &str {
+        match *self {
+            Error::MissingFrom => "missing source address, invalid envelope",
+            Error::MissingTo => "missing destination address, invalid envelope",
+            Error::InvalidEmailAddress => "invalid email address",
+        }
+    }
+
+    fn cause(&self) -> Option<&StdError> {
+        None
+    }
+}
+
+impl Display for Error {
+    fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {
+        fmt.write_str(self.description())
+    }
+}
+
+/// Email result type
+pub type EmailResult<T> = Result<T, Error>;
+
+/// Email address
+#[derive(PartialEq, Eq, Clone, Debug)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub struct EmailAddress(String);
+
+impl EmailAddress {
+    /// Creates a new `EmailAddress`. For now it makes no validation.
+    pub fn new(address: String) -> EmailResult<EmailAddress> {
+        // TODO make some basic sanity checks
+        Ok(EmailAddress(address))
+    }
+}
+
+impl FromStr for EmailAddress {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        EmailAddress::new(s.to_string())
+    }
+}
+
+impl Display for EmailAddress {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        f.write_str(&self.0)
+    }
+}
+
+/// Simple email envelope representation
+///
+/// We only accept mailboxes, and do not support source routes (as per RFC).
+#[derive(PartialEq, Eq, Clone, Debug)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub struct Envelope {
+    /// The envelope recipients' addresses
+    ///
+    /// This can not be empty.
+    forward_path: Vec<EmailAddress>,
+    /// The envelope sender address
+    reverse_path: Option<EmailAddress>,
+}
+
+impl Envelope {
+    /// Creates a new envelope, which may fail if `to` is empty.
+    pub fn new(from: Option<EmailAddress>, to: Vec<EmailAddress>) -> EmailResult<Envelope> {
+        if to.is_empty() {
+            return Err(Error::MissingTo);
+        }
+        Ok(Envelope {
+            forward_path: to,
+            reverse_path: from,
+        })
+    }
+
+    /// Destination addresses of the envelope
+    pub fn to(&self) -> &[EmailAddress] {
+        self.forward_path.as_slice()
+    }
+
+    /// Source address of the envelope
+    pub fn from(&self) -> Option<&EmailAddress> {
+        self.reverse_path.as_ref()
+    }
+
+    /// Creates a new builder
+    pub fn builder() -> EnvelopeBuilder {
+        EnvelopeBuilder::new()
+    }
+}
+
+/// Simple email envelope representation
+#[derive(PartialEq, Eq, Clone, Debug, Default)]
+pub struct EnvelopeBuilder {
+    /// The envelope recipients' addresses
+    to: Vec<EmailAddress>,
+    /// The envelope sender address
+    from: Option<EmailAddress>,
+}
+
+impl EnvelopeBuilder {
+    /// Constructs an envelope with no recipients and an empty sender
+    pub fn new() -> Self {
+        EnvelopeBuilder {
+            to: vec![],
+            from: None,
+        }
+    }
+
+    /// Adds a recipient
+    pub fn to<S: Into<EmailAddress>>(mut self, address: S) -> Self {
+        self.add_to(address);
+        self
+    }
+
+    /// Adds a recipient
+    pub fn add_to<S: Into<EmailAddress>>(&mut self, address: S) {
+        self.to.push(address.into());
+    }
+
+    /// Sets the sender
+    pub fn from<S: Into<EmailAddress>>(mut self, address: S) -> Self {
+        self.set_from(address);
+        self
+    }
+
+    /// Sets the sender
+    pub fn set_from<S: Into<EmailAddress>>(&mut self, address: S) {
+        self.from = Some(address.into());
+    }
+
+    /// Build the envelope
+    pub fn build(self) -> EmailResult<Envelope> {
+        Envelope::new(self.from, self.to)
+    }
+}
+
+/// Email sendable by an SMTP client
+pub trait SendableEmail<'a, T: Read + 'a> {
+    /// Envelope
+    fn envelope(&self) -> Envelope;
+    /// Message ID, used for logging
+    fn message_id(&self) -> String;
+    /// Message content
+    fn message(&'a self) -> Box<T>;
+}
+
+/// Transport method for emails
+pub trait EmailTransport<'a, U: Read + 'a, V> {
+    /// Sends the email
+    fn send<T: SendableEmail<'a, U> + 'a>(&mut self, email: &'a T) -> V;
+}
+
+/// Minimal email structure
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub struct SimpleSendableEmail {
+    /// Envelope
+    envelope: Envelope,
+    /// Message ID
+    message_id: String,
+    /// Message content
+    message: Vec<u8>,
+}
+
+impl SimpleSendableEmail {
+    /// Returns a new email
+    pub fn new(
+        from_address: String,
+        to_addresses: &[String],
+        message_id: String,
+        message: String,
+    ) -> EmailResult<SimpleSendableEmail> {
+        let to: Result<Vec<EmailAddress>, Error> = to_addresses
+            .iter()
+            .map(|x| EmailAddress::new(x.clone()))
+            .collect();
+        Ok(SimpleSendableEmail::new_with_envelope(
+            Envelope::new(Some(EmailAddress::new(from_address)?), to?)?,
+            message_id,
+            message,
+        ))
+    }
+
+    /// Returns a new email from a valid envelope
+    pub fn new_with_envelope(
+        envelope: Envelope,
+        message_id: String,
+        message: String,
+    ) -> SimpleSendableEmail {
+        SimpleSendableEmail {
+            envelope,
+            message_id,
+            message: message.into_bytes(),
+        }
+    }
+}
+
+impl<'a> SendableEmail<'a, &'a [u8]> for SimpleSendableEmail {
+    fn envelope(&self) -> Envelope {
+        self.envelope.clone()
+    }
+
+    fn message_id(&self) -> String {
+        self.message_id.clone()
+    }
+
+    fn message(&'a self) -> Box<&[u8]> {
+        Box::new(self.message.as_slice())
+    }
+}

lettre/src/sendmail/error.rs

@@ -0,0 +1,52 @@
+//! Error and result type for sendmail transport
+
+use self::Error::*;
+use std::error::Error as StdError;
+use std::fmt::{self, Display, Formatter};
+use std::io;
+
+/// An enum of all error kinds.
+#[derive(Debug)]
+pub enum Error {
+    /// Internal client error
+    Client(&'static str),
+    /// IO error
+    Io(io::Error),
+}
+
+impl Display for Error {
+    fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {
+        fmt.write_str(self.description())
+    }
+}
+
+impl StdError for Error {
+    fn description(&self) -> &str {
+        match *self {
+            Client(err) => err,
+            Io(ref err) => err.description(),
+        }
+    }
+
+    fn cause(&self) -> Option<&StdError> {
+        match *self {
+            Io(ref err) => Some(&*err),
+            _ => None,
+        }
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(err: io::Error) -> Error {
+        Io(err)
+    }
+}
+
+impl From<&'static str> for Error {
+    fn from(string: &'static str) -> Error {
+        Client(string)
+    }
+}
+
+/// sendmail result type
+pub type SendmailResult = Result<(), Error>;

lettre/src/sendmail/mod.rs

@@ -0,0 +1,80 @@
+//! The sendmail transport sends the email using the local sendmail command.
+//!
+
+use {EmailTransport, SendableEmail};
+use sendmail::error::SendmailResult;
+use std::io::Read;
+use std::io::prelude::*;
+use std::process::{Command, Stdio};
+
+pub mod error;
+
+/// Sends an email using the `sendmail` command
+#[derive(Debug, Default)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub struct SendmailTransport {
+    command: String,
+}
+
+impl SendmailTransport {
+    /// Creates a new transport with the default `/usr/sbin/sendmail` command
+    pub fn new() -> SendmailTransport {
+        SendmailTransport {
+            command: "/usr/sbin/sendmail".to_string(),
+        }
+    }
+
+    /// Creates a new transport to the given sendmail command
+    pub fn new_with_command<S: Into<String>>(command: S) -> SendmailTransport {
+        SendmailTransport {
+            command: command.into(),
+        }
+    }
+}
+
+impl<'a, T: Read + 'a> EmailTransport<'a, T, SendmailResult> for SendmailTransport {
+    fn send<U: SendableEmail<'a, T> + 'a>(&mut self, email: &'a U) -> SendmailResult {
+        let envelope = email.envelope();
+
+        // Spawn the sendmail command
+        let to_addresses: Vec<String> = envelope.to().iter().map(|x| x.to_string()).collect();
+        let mut process = Command::new(&self.command)
+            .args(&[
+                "-i",
+                "-f",
+                &match envelope.from() {
+                    Some(address) => address.to_string(),
+                    None => "\"\"".to_string(),
+                },
+                &to_addresses.join(" "),
+            ])
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .spawn()?;
+
+        let mut message_content = String::new();
+        let _ = email.message().read_to_string(&mut message_content);
+
+        match process
+            .stdin
+            .as_mut()
+            .unwrap()
+            .write_all(message_content.as_bytes())
+        {
+            Ok(_) => (),
+            Err(error) => return Err(From::from(error)),
+        }
+
+        info!("Wrote message to stdin");
+
+        if let Ok(output) = process.wait_with_output() {
+            if output.status.success() {
+                Ok(())
+            } else {
+                Err(From::from("The message could not be sent"))
+            }
+        } else {
+            Err(From::from("The sendmail process stopped"))
+        }
+    }
+}

lettre/src/smtp/authentication.rs

@@ -0,0 +1,213 @@
+//! Provides authentication mechanisms
+
+#[cfg(feature = "crammd5-auth")]
+use md5::Md5;
+#[cfg(feature = "crammd5-auth")]
+use hmac::{Hmac, Mac};
+#[cfg(feature = "crammd5-auth")]
+use hex;
+use smtp::NUL;
+use smtp::error::Error;
+use std::fmt::{self, Display, Formatter};
+
+/// Accepted authentication mechanisms on an encrypted connection
+/// Trying LOGIN last as it is deprecated.
+#[cfg(feature = "crammd5-auth")]
+pub const DEFAULT_ENCRYPTED_MECHANISMS: &[Mechanism] =
+    &[Mechanism::Plain, Mechanism::CramMd5, Mechanism::Login];
+/// Accepted authentication mechanisms on an encrypted connection
+/// Trying LOGIN last as it is deprecated.
+#[cfg(not(feature = "crammd5-auth"))]
+pub const DEFAULT_ENCRYPTED_MECHANISMS: &[Mechanism] = &[Mechanism::Plain, Mechanism::Login];
+
+/// Accepted authentication mechanisms on an unencrypted connection
+#[cfg(feature = "crammd5-auth")]
+pub const DEFAULT_UNENCRYPTED_MECHANISMS: &[Mechanism] = &[Mechanism::CramMd5];
+/// Accepted authentication mechanisms on an unencrypted connection
+/// When CRAMMD5 support is not enabled, no mechanisms are allowed.
+#[cfg(not(feature = "crammd5-auth"))]
+pub const DEFAULT_UNENCRYPTED_MECHANISMS: &[Mechanism] = &[];
+
+/// Convertable to user credentials
+pub trait IntoCredentials {
+    /// Converts to a `Credentials` struct
+    fn into_credentials(self) -> Credentials;
+}
+
+impl IntoCredentials for Credentials {
+    fn into_credentials(self) -> Credentials {
+        self
+    }
+}
+
+impl<S: Into<String>, T: Into<String>> IntoCredentials for (S, T) {
+    fn into_credentials(self) -> Credentials {
+        let (username, password) = self;
+        Credentials::new(username.into(), password.into())
+    }
+}
+
+/// Contains user credentials
+#[derive(PartialEq, Eq, Clone, Hash, Debug)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub struct Credentials {
+    username: String,
+    password: String,
+}
+
+impl Credentials {
+    /// Create a `Credentials` struct from username and password
+    pub fn new(username: String, password: String) -> Credentials {
+        Credentials { username, password }
+    }
+}
+
+/// Represents authentication mechanisms
+#[derive(PartialEq, Eq, Copy, Clone, Hash, Debug)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub enum Mechanism {
+    /// PLAIN authentication mechanism
+    /// RFC 4616: https://tools.ietf.org/html/rfc4616
+    Plain,
+    /// LOGIN authentication mechanism
+    /// Obsolete but needed for some providers (like office365)
+    /// https://www.ietf.org/archive/id/draft-murchison-sasl-login-00.txt
+    Login,
+    /// CRAM-MD5 authentication mechanism
+    /// RFC 2195: https://tools.ietf.org/html/rfc2195
+    #[cfg(feature = "crammd5-auth")]
+    CramMd5,
+}
+
+impl Display for Mechanism {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(
+            f,
+            "{}",
+            match *self {
+                Mechanism::Plain => "PLAIN",
+                Mechanism::Login => "LOGIN",
+                #[cfg(feature = "crammd5-auth")]
+                Mechanism::CramMd5 => "CRAM-MD5",
+            }
+        )
+    }
+}
+
+impl Mechanism {
+    /// Does the mechanism supports initial response
+    #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
+    pub fn supports_initial_response(&self) -> bool {
+        match *self {
+            Mechanism::Plain => true,
+            Mechanism::Login => false,
+            #[cfg(feature = "crammd5-auth")]
+            Mechanism::CramMd5 => false,
+        }
+    }
+
+    /// Returns the string to send to the server, using the provided username, password and
+    /// challenge in some cases
+    pub fn response(
+        &self,
+        credentials: &Credentials,
+        challenge: Option<&str>,
+    ) -> Result<String, Error> {
+        match *self {
+            Mechanism::Plain => match challenge {
+                Some(_) => Err(Error::Client("This mechanism does not expect a challenge")),
+                None => Ok(format!(
+                    "{}{}{}{}",
+                    NUL, credentials.username, NUL, credentials.password
+                )),
+            },
+            Mechanism::Login => {
+                let decoded_challenge = match challenge {
+                    Some(challenge) => challenge,
+                    None => return Err(Error::Client("This mechanism does expect a challenge")),
+                };
+
+                if vec!["User Name", "Username:", "Username"].contains(&decoded_challenge) {
+                    return Ok(credentials.username.to_string());
+                }
+
+                if vec!["Password", "Password:"].contains(&decoded_challenge) {
+                    return Ok(credentials.password.to_string());
+                }
+
+                Err(Error::Client("Unrecognized challenge"))
+            }
+            #[cfg(feature = "crammd5-auth")]
+            Mechanism::CramMd5 => {
+                let decoded_challenge = match challenge {
+                    Some(challenge) => challenge,
+                    None => return Err(Error::Client("This mechanism does expect a challenge")),
+                };
+
+                let mut hmac: Hmac<Md5> = Hmac::new_varkey(credentials.password.as_bytes())
+                    .expect("md5 should support variable key size");
+                hmac.input(decoded_challenge.as_bytes());
+
+                Ok(format!(
+                    "{} {}",
+                    credentials.username,
+                    hex::encode(hmac.result().code())
+                ))
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::{Credentials, Mechanism};
+
+    #[test]
+    fn test_plain() {
+        let mechanism = Mechanism::Plain;
+
+        let credentials = Credentials::new("username".to_string(), "password".to_string());
+
+        assert_eq!(
+            mechanism.response(&credentials, None).unwrap(),
+            "\u{0}username\u{0}password"
+        );
+        assert!(mechanism.response(&credentials, Some("test")).is_err());
+    }
+
+    #[test]
+    fn test_login() {
+        let mechanism = Mechanism::Login;
+
+        let credentials = Credentials::new("alice".to_string(), "wonderland".to_string());
+
+        assert_eq!(
+            mechanism.response(&credentials, Some("Username")).unwrap(),
+            "alice"
+        );
+        assert_eq!(
+            mechanism.response(&credentials, Some("Password")).unwrap(),
+            "wonderland"
+        );
+        assert!(mechanism.response(&credentials, None).is_err());
+    }
+
+    #[test]
+    #[cfg(feature = "crammd5-auth")]
+    fn test_cram_md5() {
+        let mechanism = Mechanism::CramMd5;
+
+        let credentials = Credentials::new("alice".to_string(), "wonderland".to_string());
+
+        assert_eq!(
+            mechanism
+                .response(
+                    &credentials,
+                    Some("PDE3ODkzLjEzMjA2NzkxMjNAdGVzc2VyYWN0LnN1c2FtLmluPg==")
+                )
+                .unwrap(),
+            "alice a540ebe4ef2304070bbc3c456c1f64c0"
+        );
+        assert!(mechanism.response(&credentials, None).is_err());
+    }
+}

lettre/src/smtp/client/mock.rs

@@ -0,0 +1,120 @@
+#![allow(missing_docs)]
+// Comes from https://github.com/inre/rust-mq/blob/master/netopt
+
+use std::io::{self, Cursor, Read, Write};
+use std::sync::{Arc, Mutex};
+
+pub type MockCursor = Cursor<Vec<u8>>;
+
+#[derive(Clone, Debug)]
+pub struct MockStream {
+    reader: Arc<Mutex<MockCursor>>,
+    writer: Arc<Mutex<MockCursor>>,
+}
+
+impl Default for MockStream {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl MockStream {
+    pub fn new() -> MockStream {
+        MockStream {
+            reader: Arc::new(Mutex::new(MockCursor::new(Vec::new()))),
+            writer: Arc::new(Mutex::new(MockCursor::new(Vec::new()))),
+        }
+    }
+
+    pub fn with_vec(vec: Vec<u8>) -> MockStream {
+        MockStream {
+            reader: Arc::new(Mutex::new(MockCursor::new(vec))),
+            writer: Arc::new(Mutex::new(MockCursor::new(Vec::new()))),
+        }
+    }
+
+    pub fn take_vec(&mut self) -> Vec<u8> {
+        let mut cursor = self.writer.lock().unwrap();
+        let vec = cursor.get_ref().to_vec();
+        cursor.set_position(0);
+        cursor.get_mut().clear();
+        vec
+    }
+
+    pub fn next_vec(&mut self, vec: &[u8]) {
+        let mut cursor = self.reader.lock().unwrap();
+        cursor.set_position(0);
+        cursor.get_mut().clear();
+        cursor.get_mut().extend_from_slice(vec);
+    }
+
+    pub fn swap(&mut self) {
+        let mut cur_write = self.writer.lock().unwrap();
+        let mut cur_read = self.reader.lock().unwrap();
+        let vec_write = cur_write.get_ref().to_vec();
+        let vec_read = cur_read.get_ref().to_vec();
+        cur_write.set_position(0);
+        cur_read.set_position(0);
+        cur_write.get_mut().clear();
+        cur_read.get_mut().clear();
+        // swap cursors
+        cur_read.get_mut().extend_from_slice(vec_write.as_slice());
+        cur_write.get_mut().extend_from_slice(vec_read.as_slice());
+    }
+}
+
+impl Write for MockStream {
+    fn write(&mut self, msg: &[u8]) -> io::Result<usize> {
+        self.writer.lock().unwrap().write(msg)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.writer.lock().unwrap().flush()
+    }
+}
+
+impl Read for MockStream {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        self.reader.lock().unwrap().read(buf)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::MockStream;
+    use std::io::{Read, Write};
+
+    #[test]
+    fn write_take_test() {
+        let mut mock = MockStream::new();
+        // write to mock stream
+        mock.write(&[1, 2, 3]).unwrap();
+        assert_eq!(mock.take_vec(), vec![1, 2, 3]);
+    }
+
+    #[test]
+    fn read_with_vec_test() {
+        let mut mock = MockStream::with_vec(vec![4, 5]);
+        let mut vec = Vec::new();
+        mock.read_to_end(&mut vec).unwrap();
+        assert_eq!(vec, vec![4, 5]);
+    }
+
+    #[test]
+    fn clone_test() {
+        let mut mock = MockStream::new();
+        let mut cloned = mock.clone();
+        mock.write(&[6, 7]).unwrap();
+        assert_eq!(cloned.take_vec(), vec![6, 7]);
+    }
+
+    #[test]
+    fn swap_test() {
+        let mut mock = MockStream::new();
+        let mut vec = Vec::new();
+        mock.write(&[8, 9, 10]).unwrap();
+        mock.swap();
+        mock.read_to_end(&mut vec).unwrap();
+        assert_eq!(vec, vec![8, 9, 10]);
+    }
+}

lettre/src/smtp/client/mod.rs

@@ -0,0 +1,306 @@
+//! SMTP client
+
+use bufstream::BufStream;
+use nom::ErrorKind as NomErrorKind;
+use smtp::{CRLF, MESSAGE_ENDING};
+use smtp::authentication::{Credentials, Mechanism};
+use smtp::client::net::{ClientTlsParameters, Connector, NetworkStream, Timeout};
+use smtp::commands::*;
+use smtp::error::{Error, SmtpResult};
+use smtp::response::Response;
+use std::fmt::{Debug, Display};
+use std::io::{self, BufRead, BufReader, Read, Write};
+use std::net::ToSocketAddrs;
+use std::string::String;
+use std::time::Duration;
+
+pub mod net;
+pub mod mock;
+
+/// The codec used for transparency
+#[derive(Default, Clone, Copy, Debug)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub struct ClientCodec {
+    escape_count: u8,
+}
+
+impl ClientCodec {
+    /// Creates a new client codec
+    pub fn new() -> Self {
+        ClientCodec::default()
+    }
+}
+
+impl ClientCodec {
+    /// Adds transparency
+    /// TODO: replace CR and LF by CRLF
+    fn encode(&mut self, frame: &[u8], buf: &mut Vec<u8>) -> Result<(), Error> {
+        match frame.len() {
+            0 => {
+                match self.escape_count {
+                    0 => buf.write_all(b"\r\n.\r\n")?,
+                    1 => buf.write_all(b"\n.\r\n")?,
+                    2 => buf.write_all(b".\r\n")?,
+                    _ => unreachable!(),
+                }
+                self.escape_count = 0;
+                Ok(())
+            }
+            _ => {
+                let mut start = 0;
+                for (idx, byte) in frame.iter().enumerate() {
+                    match self.escape_count {
+                        0 => self.escape_count = if *byte == b'\r' { 1 } else { 0 },
+                        1 => self.escape_count = if *byte == b'\n' { 2 } else { 0 },
+                        2 => self.escape_count = if *byte == b'.' { 3 } else { 0 },
+                        _ => unreachable!(),
+                    }
+                    if self.escape_count == 3 {
+                        self.escape_count = 0;
+                        buf.write_all(&frame[start..idx])?;
+                        buf.write_all(b".")?;
+                        start = idx;
+                    }
+                }
+                buf.write_all(&frame[start..])?;
+                Ok(())
+            }
+        }
+    }
+}
+
+/// Returns the string replacing all the CRLF with "\<CRLF\>"
+/// Used for debug displays
+fn escape_crlf(string: &str) -> String {
+    string.replace(CRLF, "<CRLF>")
+}
+
+/// Structure that implements the SMTP client
+#[derive(Debug, Default)]
+pub struct Client<S: Write + Read = NetworkStream> {
+    /// TCP stream between client and server
+    /// Value is None before connection
+    stream: Option<BufStream<S>>,
+}
+
+macro_rules! return_err (
+    ($err: expr, $client: ident) => ({
+        return Err(From::from($err))
+    })
+);
+
+#[cfg_attr(feature = "cargo-clippy", allow(new_without_default_derive))]
+impl<S: Write + Read> Client<S> {
+    /// Creates a new SMTP client
+    ///
+    /// It does not connects to the server, but only creates the `Client`
+    pub fn new() -> Client<S> {
+        Client { stream: None }
+    }
+}
+
+impl<S: Connector + Write + Read + Timeout + Debug> Client<S> {
+    /// Closes the SMTP transaction if possible
+    pub fn close(&mut self) {
+        let _ = self.command(QuitCommand);
+        self.stream = None;
+    }
+
+    /// Sets the underlying stream
+    pub fn set_stream(&mut self, stream: S) {
+        self.stream = Some(BufStream::new(stream));
+    }
+
+    /// Upgrades the underlying connection to SSL/TLS
+    pub fn upgrade_tls_stream(&mut self, tls_parameters: &ClientTlsParameters) -> io::Result<()> {
+        match self.stream {
+            Some(ref mut stream) => stream.get_mut().upgrade_tls(tls_parameters),
+            None => Ok(()),
+        }
+    }
+
+    /// Tells if the underlying stream is currently encrypted
+    pub fn is_encrypted(&self) -> bool {
+        match self.stream {
+            Some(ref stream) => stream.get_ref().is_encrypted(),
+            None => false,
+        }
+    }
+
+    /// Set timeout
+    pub fn set_timeout(&mut self, duration: Option<Duration>) -> io::Result<()> {
+        match self.stream {
+            Some(ref mut stream) => {
+                stream.get_mut().set_read_timeout(duration)?;
+                stream.get_mut().set_write_timeout(duration)?;
+                Ok(())
+            }
+            None => Ok(()),
+        }
+    }
+
+    /// Connects to the configured server
+    pub fn connect<A: ToSocketAddrs>(
+        &mut self,
+        addr: &A,
+        tls_parameters: Option<&ClientTlsParameters>,
+    ) -> SmtpResult {
+        // Connect should not be called when the client is already connected
+        if self.stream.is_some() {
+            return_err!("The connection is already established", self);
+        }
+
+        let mut addresses = addr.to_socket_addrs()?;
+
+        let server_addr = match addresses.next() {
+            Some(addr) => addr,
+            None => return_err!("Could not resolve hostname", self),
+        };
+
+        debug!("connecting to {}", server_addr);
+
+        // Try to connect
+        self.set_stream(Connector::connect(&server_addr, tls_parameters)?);
+
+        self.read_response()
+    }
+
+    /// Checks if the server is connected using the NOOP SMTP command
+    #[cfg_attr(feature = "cargo-clippy", allow(wrong_self_convention))]
+    pub fn is_connected(&mut self) -> bool {
+        self.command(NoopCommand).is_ok()
+    }
+
+    /// Sends an AUTH command with the given mechanism, and handles challenge if needed
+    pub fn auth(&mut self, mechanism: Mechanism, credentials: &Credentials) -> SmtpResult {
+        // TODO
+        let mut challenges = 10;
+        let mut response = self.command(AuthCommand::new(mechanism, credentials.clone(), None)?)?;
+
+        while challenges > 0 && response.has_code(334) {
+            challenges -= 1;
+            response = self.command(AuthCommand::new_from_response(
+                mechanism,
+                credentials.clone(),
+                &response,
+            )?)?;
+        }
+
+        if challenges == 0 {
+            Err(Error::ResponseParsing("Unexpected number of challenges"))
+        } else {
+            Ok(response)
+        }
+    }
+
+    /// Sends the message content
+    pub fn message<T: Read>(&mut self, mut message: Box<T>) -> SmtpResult {
+        let mut out_buf: Vec<u8> = vec![];
+        let mut codec = ClientCodec::new();
+        let mut message_reader = BufReader::new(message.as_mut());
+
+        loop {
+            out_buf.clear();
+
+            let consumed = match message_reader.fill_buf() {
+                Ok(bytes) => {
+                    codec.encode(bytes, &mut out_buf)?;
+                    bytes.len()
+                }
+                Err(ref err) => panic!("Failed with: {}", err),
+            };
+            message_reader.consume(consumed);
+
+            if consumed == 0 {
+                break;
+            }
+
+            self.write(out_buf.as_slice())?;
+        }
+
+        self.write(MESSAGE_ENDING.as_bytes())?;
+        self.read_response()
+    }
+
+    /// Sends an SMTP command
+    pub fn command<C: Display>(&mut self, command: C) -> SmtpResult {
+        self.write(command.to_string().as_bytes())?;
+        self.read_response()
+    }
+
+    /// Writes a string to the server
+    fn write(&mut self, string: &[u8]) -> Result<(), Error> {
+        if self.stream.is_none() {
+            return Err(From::from("Connection closed"));
+        }
+
+        self.stream.as_mut().unwrap().write_all(string)?;
+        self.stream.as_mut().unwrap().flush()?;
+
+        debug!(
+            "Wrote: {}",
+            escape_crlf(String::from_utf8_lossy(string).as_ref())
+        );
+        Ok(())
+    }
+
+    /// Gets the SMTP response
+    fn read_response(&mut self) -> SmtpResult {
+        let mut raw_response = String::new();
+        let mut response = raw_response.parse::<Response>();
+
+        while response.is_err() {
+            if response.as_ref().err().unwrap() != &NomErrorKind::Complete {
+                break;
+            }
+            // TODO read more than one line
+            self.stream.as_mut().unwrap().read_line(&mut raw_response)?;
+            response = raw_response.parse::<Response>();
+        }
+
+        debug!("Read: {}", escape_crlf(raw_response.as_ref()));
+
+        let final_response = response?;
+
+        if final_response.is_positive() {
+            Ok(final_response)
+        } else {
+            Err(From::from(final_response))
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::{escape_crlf, ClientCodec};
+
+    #[test]
+    fn test_codec() {
+        let mut codec = ClientCodec::new();
+        let mut buf: Vec<u8> = vec![];
+
+        assert!(codec.encode(b"test\r\n", &mut buf).is_ok());
+        assert!(codec.encode(b".\r\n", &mut buf).is_ok());
+        assert!(codec.encode(b"\r\ntest", &mut buf).is_ok());
+        assert!(codec.encode(b"te\r\n.\r\nst", &mut buf).is_ok());
+        assert!(codec.encode(b"test", &mut buf).is_ok());
+        assert!(codec.encode(b"test.", &mut buf).is_ok());
+        assert!(codec.encode(b"test\n", &mut buf).is_ok());
+        assert!(codec.encode(b".test\n", &mut buf).is_ok());
+        assert!(codec.encode(b"test", &mut buf).is_ok());
+        assert_eq!(
+            String::from_utf8(buf).unwrap(),
+            "test\r\n..\r\n\r\ntestte\r\n..\r\nsttesttest.test\n.test\ntest"
+        );
+    }
+
+    #[test]
+    fn test_escape_crlf() {
+        assert_eq!(escape_crlf("\r\n"), "<CRLF>");
+        assert_eq!(escape_crlf("EHLO my_name\r\n"), "EHLO my_name<CRLF>");
+        assert_eq!(
+            escape_crlf("EHLO my_name\r\nSIZE 42\r\n"),
+            "EHLO my_name<CRLF>SIZE 42<CRLF>"
+        );
+    }
+}

lettre/src/smtp/client/net.rs

@@ -0,0 +1,172 @@
+//! A trait to represent a stream
+
+use native_tls::{Protocol, TlsConnector, TlsStream};
+use smtp::client::mock::MockStream;
+use std::io::{self, ErrorKind, Read, Write};
+use std::net::{Ipv4Addr, Shutdown, SocketAddr, SocketAddrV4, TcpStream};
+use std::time::Duration;
+
+/// Parameters to use for secure clients
+#[derive(Clone)]
+#[allow(missing_debug_implementations)]
+pub struct ClientTlsParameters {
+    /// A connector from `native-tls`
+    pub connector: TlsConnector,
+    /// The domain to send during the TLS handshake
+    pub domain: String,
+}
+
+impl ClientTlsParameters {
+    /// Creates a `ClientTlsParameters`
+    pub fn new(domain: String, connector: TlsConnector) -> ClientTlsParameters {
+        ClientTlsParameters { connector, domain }
+    }
+}
+
+/// Accepted protocols by default.
+/// This removes TLS 1.0 compared to tls-native defaults.
+pub const DEFAULT_TLS_PROTOCOLS: &[Protocol] = &[Protocol::Tlsv11, Protocol::Tlsv12];
+
+#[derive(Debug)]
+/// Represents the different types of underlying network streams
+pub enum NetworkStream {
+    /// Plain TCP stream
+    Tcp(TcpStream),
+    /// Encrypted TCP stream
+    Tls(TlsStream<TcpStream>),
+    /// Mock stream
+    Mock(MockStream),
+}
+
+impl NetworkStream {
+    /// Returns peer's address
+    pub fn peer_addr(&self) -> io::Result<SocketAddr> {
+        match *self {
+            NetworkStream::Tcp(ref s) => s.peer_addr(),
+            NetworkStream::Tls(ref s) => s.get_ref().peer_addr(),
+            NetworkStream::Mock(_) => Ok(SocketAddr::V4(SocketAddrV4::new(
+                Ipv4Addr::new(127, 0, 0, 1),
+                80,
+            ))),
+        }
+    }
+
+    /// Shutdowns the connection
+    pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
+        match *self {
+            NetworkStream::Tcp(ref s) => s.shutdown(how),
+            NetworkStream::Tls(ref s) => s.get_ref().shutdown(how),
+            NetworkStream::Mock(_) => Ok(()),
+        }
+    }
+}
+
+impl Read for NetworkStream {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        match *self {
+            NetworkStream::Tcp(ref mut s) => s.read(buf),
+            NetworkStream::Tls(ref mut s) => s.read(buf),
+            NetworkStream::Mock(ref mut s) => s.read(buf),
+        }
+    }
+}
+
+impl Write for NetworkStream {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        match *self {
+            NetworkStream::Tcp(ref mut s) => s.write(buf),
+            NetworkStream::Tls(ref mut s) => s.write(buf),
+            NetworkStream::Mock(ref mut s) => s.write(buf),
+        }
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        match *self {
+            NetworkStream::Tcp(ref mut s) => s.flush(),
+            NetworkStream::Tls(ref mut s) => s.flush(),
+            NetworkStream::Mock(ref mut s) => s.flush(),
+        }
+    }
+}
+
+/// A trait for the concept of opening a stream
+pub trait Connector: Sized {
+    /// Opens a connection to the given IP socket
+    fn connect(addr: &SocketAddr, tls_parameters: Option<&ClientTlsParameters>)
+        -> io::Result<Self>;
+    /// Upgrades to TLS connection
+    fn upgrade_tls(&mut self, tls_parameters: &ClientTlsParameters) -> io::Result<()>;
+    /// Is the NetworkStream encrypted
+    fn is_encrypted(&self) -> bool;
+}
+
+impl Connector for NetworkStream {
+    fn connect(
+        addr: &SocketAddr,
+        tls_parameters: Option<&ClientTlsParameters>,
+    ) -> io::Result<NetworkStream> {
+        let tcp_stream = TcpStream::connect(addr)?;
+
+        match tls_parameters {
+            Some(context) => context
+                .connector
+                .connect(context.domain.as_ref(), tcp_stream)
+                .map(NetworkStream::Tls)
+                .map_err(|e| io::Error::new(ErrorKind::Other, e)),
+            None => Ok(NetworkStream::Tcp(tcp_stream)),
+        }
+    }
+
+    #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
+    fn upgrade_tls(&mut self, tls_parameters: &ClientTlsParameters) -> io::Result<()> {
+        *self = match *self {
+            NetworkStream::Tcp(ref mut stream) => match tls_parameters
+                .connector
+                .connect(tls_parameters.domain.as_ref(), stream.try_clone().unwrap())
+            {
+                Ok(tls_stream) => NetworkStream::Tls(tls_stream),
+                Err(err) => return Err(io::Error::new(ErrorKind::Other, err)),
+            },
+            NetworkStream::Tls(_) => return Ok(()),
+            NetworkStream::Mock(_) => return Ok(()),
+        };
+
+        Ok(())
+    }
+
+    #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
+    fn is_encrypted(&self) -> bool {
+        match *self {
+            NetworkStream::Tcp(_) => false,
+            NetworkStream::Tls(_) => true,
+            NetworkStream::Mock(_) => false,
+        }
+    }
+}
+
+/// A trait for read and write timeout support
+pub trait Timeout: Sized {
+    /// Set read timeout for IO calls
+    fn set_read_timeout(&mut self, duration: Option<Duration>) -> io::Result<()>;
+    /// Set write timeout for IO calls
+    fn set_write_timeout(&mut self, duration: Option<Duration>) -> io::Result<()>;
+}
+
+impl Timeout for NetworkStream {
+    fn set_read_timeout(&mut self, duration: Option<Duration>) -> io::Result<()> {
+        match *self {
+            NetworkStream::Tcp(ref mut stream) => stream.set_read_timeout(duration),
+            NetworkStream::Tls(ref mut stream) => stream.get_ref().set_read_timeout(duration),
+            NetworkStream::Mock(_) => Ok(()),
+        }
+    }
+
+    /// Set write timeout for IO calls
+    fn set_write_timeout(&mut self, duration: Option<Duration>) -> io::Result<()> {
+        match *self {
+            NetworkStream::Tcp(ref mut stream) => stream.set_write_timeout(duration),
+            NetworkStream::Tls(ref mut stream) => stream.get_ref().set_write_timeout(duration),
+            NetworkStream::Mock(_) => Ok(()),
+        }
+    }
+}

lettre/src/smtp/commands.rs

@@ -0,0 +1,433 @@
+//! SMTP commands
+
+use EmailAddress;
+use base64;
+use smtp::CRLF;
+use smtp::authentication::{Credentials, Mechanism};
+use smtp::error::Error;
+use smtp::extension::{MailParameter, RcptParameter};
+use smtp::extension::ClientId;
+use smtp::response::Response;
+use std::fmt::{self, Display, Formatter};
+
+/// EHLO command
+#[derive(PartialEq, Clone, Debug)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub struct EhloCommand {
+    client_id: ClientId,
+}
+
+impl Display for EhloCommand {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "EHLO {}", self.client_id)?;
+        f.write_str(CRLF)
+    }
+}
+
+impl EhloCommand {
+    /// Creates a EHLO command
+    pub fn new(client_id: ClientId) -> EhloCommand {
+        EhloCommand { client_id }
+    }
+}
+
+/// STARTTLS command
+#[derive(PartialEq, Clone, Debug, Copy)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub struct StarttlsCommand;
+
+impl Display for StarttlsCommand {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        f.write_str("STARTTLS")?;
+        f.write_str(CRLF)
+    }
+}
+
+/// MAIL command
+#[derive(PartialEq, Clone, Debug)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub struct MailCommand {
+    sender: Option<EmailAddress>,
+    parameters: Vec<MailParameter>,
+}
+
+impl Display for MailCommand {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(
+            f,
+            "MAIL FROM:<{}>",
+            match self.sender {
+                Some(ref address) => address.to_string(),
+                None => "".to_string(),
+            }
+        )?;
+        for parameter in &self.parameters {
+            write!(f, " {}", parameter)?;
+        }
+        f.write_str(CRLF)
+    }
+}
+
+impl MailCommand {
+    /// Creates a MAIL command
+    pub fn new(sender: Option<EmailAddress>, parameters: Vec<MailParameter>) -> MailCommand {
+        MailCommand { sender, parameters }
+    }
+}
+
+/// RCPT command
+#[derive(PartialEq, Clone, Debug)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub struct RcptCommand {
+    recipient: EmailAddress,
+    parameters: Vec<RcptParameter>,
+}
+
+impl Display for RcptCommand {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "RCPT TO:<{}>", self.recipient)?;
+        for parameter in &self.parameters {
+            write!(f, " {}", parameter)?;
+        }
+        f.write_str(CRLF)
+    }
+}
+
+impl RcptCommand {
+    /// Creates an RCPT command
+    pub fn new(recipient: EmailAddress, parameters: Vec<RcptParameter>) -> RcptCommand {
+        RcptCommand {
+            recipient,
+            parameters,
+        }
+    }
+}
+
+/// DATA command
+#[derive(PartialEq, Clone, Debug, Copy)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub struct DataCommand;
+
+impl Display for DataCommand {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        f.write_str("DATA")?;
+        f.write_str(CRLF)
+    }
+}
+
+/// QUIT command
+#[derive(PartialEq, Clone, Debug, Copy)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub struct QuitCommand;
+
+impl Display for QuitCommand {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        f.write_str("QUIT")?;
+        f.write_str(CRLF)
+    }
+}
+
+/// NOOP command
+#[derive(PartialEq, Clone, Debug, Copy)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub struct NoopCommand;
+
+impl Display for NoopCommand {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        f.write_str("NOOP")?;
+        f.write_str(CRLF)
+    }
+}
+
+/// HELP command
+#[derive(PartialEq, Clone, Debug)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub struct HelpCommand {
+    argument: Option<String>,
+}
+
+impl Display for HelpCommand {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        f.write_str("HELP")?;
+        if self.argument.is_some() {
+            write!(f, " {}", self.argument.as_ref().unwrap())?;
+        }
+        f.write_str(CRLF)
+    }
+}
+
+impl HelpCommand {
+    /// Creates an HELP command
+    pub fn new(argument: Option<String>) -> HelpCommand {
+        HelpCommand { argument }
+    }
+}
+
+/// VRFY command
+#[derive(PartialEq, Clone, Debug)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub struct VrfyCommand {
+    argument: String,
+}
+
+impl Display for VrfyCommand {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "VRFY {}", self.argument)?;
+        f.write_str(CRLF)
+    }
+}
+
+impl VrfyCommand {
+    /// Creates a VRFY command
+    pub fn new(argument: String) -> VrfyCommand {
+        VrfyCommand { argument }
+    }
+}
+
+/// EXPN command
+#[derive(PartialEq, Clone, Debug)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub struct ExpnCommand {
+    argument: String,
+}
+
+impl Display for ExpnCommand {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "EXPN {}", self.argument)?;
+        f.write_str(CRLF)
+    }
+}
+
+impl ExpnCommand {
+    /// Creates an EXPN command
+    pub fn new(argument: String) -> ExpnCommand {
+        ExpnCommand { argument }
+    }
+}
+
+/// RSET command
+#[derive(PartialEq, Clone, Debug, Copy)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub struct RsetCommand;
+
+impl Display for RsetCommand {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        f.write_str("RSET")?;
+        f.write_str(CRLF)
+    }
+}
+
+/// AUTH command
+#[derive(PartialEq, Clone, Debug)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub struct AuthCommand {
+    mechanism: Mechanism,
+    credentials: Credentials,
+    challenge: Option<String>,
+    response: Option<String>,
+}
+
+impl Display for AuthCommand {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        let encoded_response = if self.response.is_some() {
+            Some(base64::encode_config(
+                self.response.as_ref().unwrap().as_bytes(),
+                base64::STANDARD,
+            ))
+        } else {
+            None
+        };
+
+        if self.mechanism.supports_initial_response() {
+            write!(f, "AUTH {} {}", self.mechanism, encoded_response.unwrap(),)?;
+        } else {
+            match encoded_response {
+                Some(response) => f.write_str(&response)?,
+                None => write!(f, "AUTH {}", self.mechanism)?,
+            }
+        }
+        f.write_str(CRLF)
+    }
+}
+
+impl AuthCommand {
+    /// Creates an AUTH command (from a challenge if provided)
+    pub fn new(
+        mechanism: Mechanism,
+        credentials: Credentials,
+        challenge: Option<String>,
+    ) -> Result<AuthCommand, Error> {
+        let response = if mechanism.supports_initial_response() || challenge.is_some() {
+            Some(mechanism.response(&credentials, challenge.as_ref().map(String::as_str))?)
+        } else {
+            None
+        };
+        Ok(AuthCommand {
+            mechanism,
+            credentials,
+            challenge,
+            response,
+        })
+    }
+
+    /// Creates an AUTH command from a response that needs to be a
+    /// valid challenge (with 334 response code)
+    pub fn new_from_response(
+        mechanism: Mechanism,
+        credentials: Credentials,
+        response: &Response,
+    ) -> Result<AuthCommand, Error> {
+        if !response.has_code(334) {
+            return Err(Error::ResponseParsing("Expecting a challenge"));
+        }
+
+        let encoded_challenge = match response.first_word() {
+            Some(challenge) => challenge.to_string(),
+            None => return Err(Error::ResponseParsing("Could not read auth challenge")),
+        };
+
+        debug!("auth encoded challenge: {}", encoded_challenge);
+
+        let decoded_challenge = match base64::decode(&encoded_challenge) {
+            Ok(challenge) => match String::from_utf8(challenge) {
+                Ok(value) => value,
+                Err(error) => return Err(Error::Utf8Parsing(error)),
+            },
+            Err(error) => return Err(Error::ChallengeParsing(error)),
+        };
+
+        debug!("auth decoded challenge: {}", decoded_challenge);
+
+        let response = Some(mechanism.response(&credentials, Some(decoded_challenge.as_ref()))?);
+
+        Ok(AuthCommand {
+            mechanism,
+            credentials,
+            challenge: Some(decoded_challenge),
+            response,
+        })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use smtp::extension::MailBodyParameter;
+    #[cfg(feature = "crammd5-auth")]
+    use smtp::response::{Category, Code, Detail, Severity};
+
+    #[test]
+    fn test_display() {
+        let id = ClientId::Domain("localhost".to_string());
+        let email = EmailAddress::new("test@example.com".to_string()).unwrap();
+        let mail_parameter = MailParameter::Other {
+            keyword: "TEST".to_string(),
+            value: Some("value".to_string()),
+        };
+        let rcpt_parameter = RcptParameter::Other {
+            keyword: "TEST".to_string(),
+            value: Some("value".to_string()),
+        };
+        assert_eq!(format!("{}", EhloCommand::new(id)), "EHLO localhost\r\n");
+        assert_eq!(
+            format!("{}", MailCommand::new(Some(email.clone()), vec![])),
+            "MAIL FROM:<test@example.com>\r\n"
+        );
+        assert_eq!(
+            format!("{}", MailCommand::new(None, vec![])),
+            "MAIL FROM:<>\r\n"
+        );
+        assert_eq!(
+            format!(
+                "{}",
+                MailCommand::new(Some(email.clone()), vec![MailParameter::Size(42)])
+            ),
+            "MAIL FROM:<test@example.com> SIZE=42\r\n"
+        );
+        assert_eq!(
+            format!(
+                "{}",
+                MailCommand::new(
+                    Some(email.clone()),
+                    vec![
+                        MailParameter::Size(42),
+                        MailParameter::Body(MailBodyParameter::EightBitMime),
+                        mail_parameter,
+                    ],
+                )
+            ),
+            "MAIL FROM:<test@example.com> SIZE=42 BODY=8BITMIME TEST=value\r\n"
+        );
+        assert_eq!(
+            format!("{}", RcptCommand::new(email.clone(), vec![])),
+            "RCPT TO:<test@example.com>\r\n"
+        );
+        assert_eq!(
+            format!("{}", RcptCommand::new(email.clone(), vec![rcpt_parameter])),
+            "RCPT TO:<test@example.com> TEST=value\r\n"
+        );
+        assert_eq!(format!("{}", QuitCommand), "QUIT\r\n");
+        assert_eq!(format!("{}", DataCommand), "DATA\r\n");
+        assert_eq!(format!("{}", NoopCommand), "NOOP\r\n");
+        assert_eq!(format!("{}", HelpCommand::new(None)), "HELP\r\n");
+        assert_eq!(
+            format!("{}", HelpCommand::new(Some("test".to_string()))),
+            "HELP test\r\n"
+        );
+        assert_eq!(
+            format!("{}", VrfyCommand::new("test".to_string())),
+            "VRFY test\r\n"
+        );
+        assert_eq!(
+            format!("{}", ExpnCommand::new("test".to_string())),
+            "EXPN test\r\n"
+        );
+        assert_eq!(format!("{}", RsetCommand), "RSET\r\n");
+        let credentials = Credentials::new("user".to_string(), "password".to_string());
+        assert_eq!(
+            format!(
+                "{}",
+                AuthCommand::new(Mechanism::Plain, credentials.clone(), None).unwrap()
+            ),
+            "AUTH PLAIN AHVzZXIAcGFzc3dvcmQ=\r\n"
+        );
+        #[cfg(feature = "crammd5-auth")]
+        assert_eq!(
+            format!(
+                "{}",
+                AuthCommand::new(
+                    Mechanism::CramMd5,
+                    credentials.clone(),
+                    Some("test".to_string()),
+                ).unwrap()
+            ),
+            "dXNlciAzMTYxY2NmZDdmMjNlMzJiYmMzZTQ4NjdmYzk0YjE4Nw==\r\n"
+        );
+        assert_eq!(
+            format!(
+                "{}",
+                AuthCommand::new(Mechanism::Login, credentials.clone(), None).unwrap()
+            ),
+            "AUTH LOGIN\r\n"
+        );
+        #[cfg(feature = "crammd5-auth")]
+        assert_eq!(
+            format!(
+                "{}",
+                AuthCommand::new_from_response(
+                    Mechanism::CramMd5,
+                    credentials.clone(),
+                    &Response::new(
+                        Code::new(
+                            Severity::PositiveIntermediate,
+                            Category::Unspecified3,
+                            Detail::Four,
+                        ),
+                        vec!["dGVzdAo=".to_string()],
+                    ),
+                ).unwrap()
+            ),
+            "dXNlciA1NTIzNThiMzExOWFjOWNkYzM2YWRiN2MxNWRmMWJkNw==\r\n"
+        );
+    }
+}

lettre/src/smtp/error.rs

@@ -0,0 +1,121 @@
+//! Error and result type for SMTP clients
+
+use self::Error::*;
+use base64::DecodeError;
+use native_tls;
+use nom;
+use smtp::response::{Response, Severity};
+use std::error::Error as StdError;
+use std::fmt;
+use std::fmt::{Display, Formatter};
+use std::io;
+use std::string::FromUtf8Error;
+
+/// An enum of all error kinds.
+#[derive(Debug)]
+pub enum Error {
+    /// Transient SMTP error, 4xx reply code
+    ///
+    /// [RFC 5321, section 4.2.1](https://tools.ietf.org/html/rfc5321#section-4.2.1)
+    Transient(Response),
+    /// Permanent SMTP error, 5xx reply code
+    ///
+    /// [RFC 5321, section 4.2.1](https://tools.ietf.org/html/rfc5321#section-4.2.1)
+    Permanent(Response),
+    /// Error parsing a response
+    ResponseParsing(&'static str),
+    /// Error parsing a base64 string in response
+    ChallengeParsing(DecodeError),
+    /// Error parsing UTF8in response
+    Utf8Parsing(FromUtf8Error),
+    /// Internal client error
+    Client(&'static str),
+    /// DNS resolution error
+    Resolution,
+    /// IO error
+    Io(io::Error),
+    /// TLS error
+    Tls(native_tls::Error),
+    /// Parsing error
+    Parsing(nom::simple_errors::Err),
+}
+
+impl Display for Error {
+    fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {
+        fmt.write_str(self.description())
+    }
+}
+
+impl StdError for Error {
+    #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
+    fn description(&self) -> &str {
+        match *self {
+            // Try to display the first line of the server's response that usually
+            // contains a short humanly readable error message
+            Transient(ref err) => match err.first_line() {
+                Some(line) => line,
+                None => "undetailed transient error during SMTP transaction",
+            },
+            Permanent(ref err) => match err.first_line() {
+                Some(line) => line,
+                None => "undetailed permanent error during SMTP transaction",
+            },
+            ResponseParsing(err) => err,
+            ChallengeParsing(ref err) => err.description(),
+            Utf8Parsing(ref err) => err.description(),
+            Resolution => "could not resolve hostname",
+            Client(err) => err,
+            Io(ref err) => err.description(),
+            Tls(ref err) => err.description(),
+            Parsing(ref err) => err.description(),
+        }
+    }
+
+    fn cause(&self) -> Option<&StdError> {
+        match *self {
+            ChallengeParsing(ref err) => Some(&*err),
+            Utf8Parsing(ref err) => Some(&*err),
+            Io(ref err) => Some(&*err),
+            Tls(ref err) => Some(&*err),
+            Parsing(ref err) => Some(&*err),
+            _ => None,
+        }
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(err: io::Error) -> Error {
+        Io(err)
+    }
+}
+
+impl From<native_tls::Error> for Error {
+    fn from(err: native_tls::Error) -> Error {
+        Tls(err)
+    }
+}
+
+impl From<nom::simple_errors::Err> for Error {
+    fn from(err: nom::simple_errors::Err) -> Error {
+        Parsing(err)
+    }
+}
+
+impl From<Response> for Error {
+    fn from(response: Response) -> Error {
+        match response.code.severity {
+            Severity::TransientNegativeCompletion => Transient(response),
+            Severity::PermanentNegativeCompletion => Permanent(response),
+            _ => Client("Unknown error code"),
+        }
+    }
+}
+
+impl From<&'static str> for Error {
+    fn from(string: &'static str) -> Error {
+        Client(string)
+    }
+}
+
+/// SMTP result type
+pub type SmtpResult = Result<Response, Error>;

lettre/src/smtp/extension.rs

@@ -1,22 +1,21 @@
 //! ESMTP features
 
-use crate::transport::smtp::{
-    authentication::Mechanism,
-    error::{self, Error},
-    response::Response,
-    util::XText,
-};
-use std::{
-    collections::HashSet,
-    fmt::{self, Display, Formatter},
-    net::{Ipv4Addr, Ipv6Addr},
-    result::Result,
-};
+use hostname::get_hostname;
+use smtp::authentication::Mechanism;
+use smtp::error::Error;
+use smtp::response::Response;
+use smtp::util::XText;
+use std::collections::HashSet;
+use std::fmt::{self, Display, Formatter};
+use std::net::{Ipv4Addr, Ipv6Addr};
+use std::result::Result;
+
+/// Default ehlo clinet id
+pub const DEFAULT_EHLO_HOSTNAME: &str = "localhost";
 
 /// Client identifier, the parameter to `EHLO`
 #[derive(PartialEq, Eq, Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-#[non_exhaustive]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
 pub enum ClientId {
     /// A fully-qualified domain name
     Domain(String),
@@ -26,83 +25,66 @@ pub enum ClientId {
     Ipv6(Ipv6Addr),
 }
 
-const LOCALHOST_CLIENT: ClientId = ClientId::Ipv4(Ipv4Addr::new(127, 0, 0, 1));
-
-impl Default for ClientId {
-    fn default() -> Self {
-        // https://tools.ietf.org/html/rfc5321#section-4.1.4
-        //
-        // The SMTP client MUST, if possible, ensure that the domain parameter
-        // to the EHLO command is a primary host name as specified for this
-        // command in Section 2.3.5.  If this is not possible (e.g., when the
-        // client's address is dynamically assigned and the client does not have
-        // an obvious name), an address literal SHOULD be substituted for the
-        // domain name.
-        #[cfg(feature = "hostname")]
-        {
-            hostname::get()
-                .ok()
-                .and_then(|s| s.into_string().map(Self::Domain).ok())
-                .unwrap_or(LOCALHOST_CLIENT)
-        }
-        #[cfg(not(feature = "hostname"))]
-        LOCALHOST_CLIENT
-    }
-}
-
 impl Display for ClientId {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         match *self {
-            Self::Domain(ref value) => f.write_str(value),
-            Self::Ipv4(ref value) => write!(f, "[{}]", value),
-            Self::Ipv6(ref value) => write!(f, "[IPv6:{}]", value),
+            ClientId::Domain(ref value) => f.write_str(value),
+            ClientId::Ipv4(ref value) => write!(f, "{}", value),
+            ClientId::Ipv6(ref value) => write!(f, "{}", value),
         }
     }
 }
 
 impl ClientId {
-    #[doc(hidden)]
-    #[deprecated(since = "0.10.0", note = "Please use ClientId::Domain(domain) instead")]
     /// Creates a new `ClientId` from a fully qualified domain name
-    pub fn new(domain: String) -> Self {
-        Self::Domain(domain)
+    pub fn new(domain: String) -> ClientId {
+        ClientId::Domain(domain)
+    }
+
+    /// Defines a `ClientId` with the current hostname, of `localhost` if hostname could not be
+    /// found
+    pub fn hostname() -> ClientId {
+        ClientId::Domain(match get_hostname() {
+            Some(name) => name,
+            None => DEFAULT_EHLO_HOSTNAME.to_string(),
+        })
     }
 }
 
 /// Supported ESMTP keywords
 #[derive(PartialEq, Eq, Hash, Copy, Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
 pub enum Extension {
     /// 8BITMIME keyword
     ///
-    /// Defined in [RFC 6152](https://tools.ietf.org/html/rfc6152)
+    /// RFC 6152: https://tools.ietf.org/html/rfc6152
     EightBitMime,
     /// SMTPUTF8 keyword
     ///
-    /// Defined in [RFC 6531](https://tools.ietf.org/html/rfc6531)
+    /// RFC 6531: https://tools.ietf.org/html/rfc6531
     SmtpUtfEight,
     /// STARTTLS keyword
     ///
-    /// Defined in [RFC 2487](https://tools.ietf.org/html/rfc2487)
+    /// RFC 2487: https://tools.ietf.org/html/rfc2487
     StartTls,
     /// AUTH mechanism
     Authentication(Mechanism),
 }
 
 impl Display for Extension {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         match *self {
-            Extension::EightBitMime => f.write_str("8BITMIME"),
-            Extension::SmtpUtfEight => f.write_str("SMTPUTF8"),
-            Extension::StartTls => f.write_str("STARTTLS"),
+            Extension::EightBitMime => write!(f, "8BITMIME"),
+            Extension::SmtpUtfEight => write!(f, "SMTPUTF8"),
+            Extension::StartTls => write!(f, "STARTTLS"),
             Extension::Authentication(ref mechanism) => write!(f, "AUTH {}", mechanism),
         }
     }
 }
 
 /// Contains information about an SMTP server
-#[derive(Clone, Debug, Eq, PartialEq, Default)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
 pub struct ServerInfo {
     /// Server name
     ///
@@ -115,13 +97,17 @@ 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()
-        } else {
-            format!("{:?}", self.features)
-        };
-        write!(f, "{} with {}", self.name, features)
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(
+            f,
+            "{} with {}",
+            self.name,
+            if self.features.is_empty() {
+                "no supported features".to_string()
+            } else {
+                format!("{:?}", self.features)
+            }
+        )
     }
 }
 
@@ -130,7 +116,7 @@ impl ServerInfo {
     pub fn from_response(response: &Response) -> Result<ServerInfo, Error> {
         let name = match response.first_word() {
             Some(name) => name,
-            None => return Err(error::response("Could not read server name")),
+            None => return Err(Error::ResponseParsing("Could not read server name")),
         };
 
         let mut features: HashSet<Extension> = HashSet::new();
@@ -140,8 +126,8 @@ impl ServerInfo {
                 continue;
             }
 
-            let mut split = line.split_whitespace();
-            match split.next().unwrap() {
+            let split: Vec<&str> = line.split_whitespace().collect();
+            match split[0] {
                 "8BITMIME" => {
                     features.insert(Extension::EightBitMime);
                 }
@@ -151,22 +137,21 @@ impl ServerInfo {
                 "STARTTLS" => {
                     features.insert(Extension::StartTls);
                 }
-                "AUTH" => {
-                    for mechanism in split {
-                        match mechanism {
-                            "PLAIN" => {
-                                features.insert(Extension::Authentication(Mechanism::Plain));
-                            }
-                            "LOGIN" => {
-                                features.insert(Extension::Authentication(Mechanism::Login));
-                            }
-                            "XOAUTH2" => {
-                                features.insert(Extension::Authentication(Mechanism::Xoauth2));
-                            }
-                            _ => (),
+                "AUTH" => for &mechanism in &split[1..] {
+                    match mechanism {
+                        "PLAIN" => {
+                            features.insert(Extension::Authentication(Mechanism::Plain));
                         }
+                        "LOGIN" => {
+                            features.insert(Extension::Authentication(Mechanism::Login));
+                        }
+                        #[cfg(feature = "crammd5-auth")]
+                        "CRAM-MD5" => {
+                            features.insert(Extension::Authentication(Mechanism::CramMd5));
+                        }
+                        _ => (),
                     }
-                }
+                },
                 _ => (),
             };
         }
@@ -187,21 +172,11 @@ impl ServerInfo {
         self.features
             .contains(&Extension::Authentication(mechanism))
     }
-
-    /// Gets a compatible mechanism from list
-    pub fn get_auth_mechanism(&self, mechanisms: &[Mechanism]) -> Option<Mechanism> {
-        for mechanism in mechanisms {
-            if self.supports_auth_mechanism(*mechanism) {
-                return Some(*mechanism);
-            }
-        }
-        None
-    }
 }
 
 /// A `MAIL FROM` extension parameter
 #[derive(PartialEq, Eq, Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
 pub enum MailParameter {
     /// `BODY` parameter
     Body(MailBodyParameter),
@@ -219,7 +194,7 @@ pub enum MailParameter {
 }
 
 impl Display for MailParameter {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         match *self {
             MailParameter::Body(ref value) => write!(f, "BODY={}", value),
             MailParameter::Size(size) => write!(f, "SIZE={}", size),
@@ -238,7 +213,7 @@ impl Display for MailParameter {
 
 /// Values for the `BODY` parameter to `MAIL FROM`
 #[derive(PartialEq, Eq, Clone, Debug, Copy)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
 pub enum MailBodyParameter {
     /// `7BIT`
     SevenBit,
@@ -247,7 +222,7 @@ pub enum MailBodyParameter {
 }
 
 impl Display for MailBodyParameter {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         match *self {
             MailBodyParameter::SevenBit => f.write_str("7BIT"),
             MailBodyParameter::EightBitMime => f.write_str("8BITMIME"),
@@ -257,7 +232,7 @@ impl Display for MailBodyParameter {
 
 /// A `RCPT TO` extension parameter
 #[derive(PartialEq, Eq, Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
 pub enum RcptParameter {
     /// Custom parameter
     Other {
@@ -269,7 +244,7 @@ pub enum RcptParameter {
 }
 
 impl Display for RcptParameter {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         match *self {
             RcptParameter::Other {
                 ref keyword,
@@ -286,20 +261,17 @@ impl Display for RcptParameter {
 #[cfg(test)]
 mod test {
 
-    use super::*;
-    use crate::transport::smtp::{
-        authentication::Mechanism,
-        response::{Category, Code, Detail, Response, Severity},
-    };
+    use super::{ClientId, Extension, ServerInfo};
+    use smtp::authentication::Mechanism;
+    use smtp::response::{Category, Code, Detail, Response, Severity};
     use std::collections::HashSet;
 
     #[test]
     fn test_clientid_fmt() {
         assert_eq!(
-            format!("{}", ClientId::Domain("test".to_string())),
+            format!("{}", ClientId::new("test".to_string())),
             "test".to_string()
         );
-        assert_eq!(format!("{}", LOCALHOST_CLIENT), "[127.0.0.1]".to_string());
     }
 
     #[test]
@@ -324,7 +296,7 @@ mod test {
                 "{}",
                 ServerInfo {
                     name: "name".to_string(),
-                    features: eightbitmime,
+                    features: eightbitmime.clone(),
                 }
             ),
             "name with {EightBitMime}".to_string()
@@ -351,7 +323,7 @@ mod test {
                 "{}",
                 ServerInfo {
                     name: "name".to_string(),
-                    features: plain,
+                    features: plain.clone(),
                 }
             ),
             "name with {Authentication(Plain)}".to_string()
@@ -385,6 +357,8 @@ mod test {
 
         assert!(server_info.supports_feature(Extension::EightBitMime));
         assert!(!server_info.supports_feature(Extension::StartTls));
+        #[cfg(feature = "crammd5-auth")]
+        assert!(!server_info.supports_auth_mechanism(Mechanism::CramMd5));
 
         let response2 = Response::new(
             Code::new(
@@ -394,7 +368,7 @@ mod test {
             ),
             vec![
                 "me".to_string(),
-                "AUTH PLAIN CRAM-MD5 XOAUTH2 OTHER".to_string(),
+                "AUTH PLAIN CRAM-MD5 OTHER".to_string(),
                 "8BITMIME".to_string(),
                 "SIZE 42".to_string(),
             ],
@@ -403,7 +377,8 @@ mod test {
         let mut features2 = HashSet::new();
         assert!(features2.insert(Extension::EightBitMime));
         assert!(features2.insert(Extension::Authentication(Mechanism::Plain),));
-        assert!(features2.insert(Extension::Authentication(Mechanism::Xoauth2),));
+        #[cfg(feature = "crammd5-auth")]
+        assert!(features2.insert(Extension::Authentication(Mechanism::CramMd5),));
 
         let server_info2 = ServerInfo {
             name: "me".to_string(),
@@ -414,6 +389,8 @@ mod test {
 
         assert!(server_info2.supports_feature(Extension::EightBitMime));
         assert!(server_info2.supports_auth_mechanism(Mechanism::Plain));
+        #[cfg(feature = "crammd5-auth")]
+        assert!(server_info2.supports_auth_mechanism(Mechanism::CramMd5));
         assert!(!server_info2.supports_feature(Extension::StartTls));
     }
 }

lettre/src/smtp/mod.rs

@@ -0,0 +1,485 @@
+//! The SMTP transport sends emails using the SMTP protocol.
+//!
+//! This SMTP client follows [RFC
+//! 5321](https://tools.ietf.org/html/rfc5321), and is designed to efficiently send emails from an
+//! application to a relay email server, as it relies as much as possible on the relay server
+//! for sanity and RFC compliance checks.
+//!
+//! It implements the following extensions:
+//!
+//! * 8BITMIME ([RFC 6152](https://tools.ietf.org/html/rfc6152))
+//! * AUTH ([RFC 4954](http://tools.ietf.org/html/rfc4954)) with PLAIN, LOGIN and
+//! CRAM-MD5 mechanisms
+//! * STARTTLS ([RFC 2487](http://tools.ietf.org/html/rfc2487))
+//! * SMTPUTF8 ([RFC 6531](http://tools.ietf.org/html/rfc6531))
+//!
+
+use EmailTransport;
+use SendableEmail;
+use native_tls::TlsConnector;
+use smtp::authentication::{Credentials, Mechanism, DEFAULT_ENCRYPTED_MECHANISMS,
+                           DEFAULT_UNENCRYPTED_MECHANISMS};
+use smtp::client::Client;
+use smtp::client::net::ClientTlsParameters;
+use smtp::client::net::DEFAULT_TLS_PROTOCOLS;
+use smtp::commands::*;
+use smtp::error::{Error, SmtpResult};
+use smtp::extension::{ClientId, Extension, MailBodyParameter, MailParameter, ServerInfo};
+use std::io::Read;
+use std::net::{SocketAddr, ToSocketAddrs};
+use std::time::Duration;
+
+pub mod extension;
+pub mod commands;
+pub mod authentication;
+pub mod response;
+pub mod client;
+pub mod error;
+pub mod util;
+
+// Registered port numbers:
+// https://www.iana.
+// org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml
+
+/// Default smtp port
+pub const SMTP_PORT: u16 = 25;
+
+/// Default submission port
+pub const SUBMISSION_PORT: u16 = 587;
+
+// Useful strings and characters
+
+/// The word separator for SMTP transactions
+pub const SP: &str = " ";
+
+/// The line ending for SMTP transactions (carriage return + line feed)
+pub const CRLF: &str = "\r\n";
+
+/// Colon
+pub const COLON: &str = ":";
+
+/// The ending of message content
+pub const MESSAGE_ENDING: &str = "\r\n.\r\n";
+
+/// NUL unicode character
+pub const NUL: &str = "\0";
+
+/// How to apply TLS to a client connection
+#[derive(Clone)]
+#[allow(missing_debug_implementations)]
+pub enum ClientSecurity {
+    /// Insecure connection
+    None,
+    /// Use `STARTTLS` when available
+    Opportunistic(ClientTlsParameters),
+    /// Always use `STARTTLS`
+    Required(ClientTlsParameters),
+    /// Use TLS wrapped connection without negotiation
+    /// Non RFC-compliant, should only be used if the server does not support STARTTLS.
+    Wrapper(ClientTlsParameters),
+}
+
+/// Configures connection reuse behavior
+#[derive(Clone, Debug, Copy)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub enum ConnectionReuseParameters {
+    /// Unlimited connection reuse
+    ReuseUnlimited,
+    /// Maximum number of connection reuse
+    ReuseLimited(u16),
+    /// Disable connection reuse, close connection after each transaction
+    NoReuse,
+}
+
+/// Contains client configuration
+#[allow(missing_debug_implementations)]
+pub struct SmtpTransportBuilder {
+    /// Enable connection reuse
+    connection_reuse: ConnectionReuseParameters,
+    /// Name sent during EHLO
+    hello_name: ClientId,
+    /// Credentials
+    credentials: Option<Credentials>,
+    /// Socket we are connecting to
+    server_addr: SocketAddr,
+    /// TLS security configuration
+    security: ClientSecurity,
+    /// Enable UTF8 mailboxes in envelope or headers
+    smtp_utf8: bool,
+    /// Optional enforced authentication mechanism
+    authentication_mechanism: Option<Mechanism>,
+    /// Define network timeout
+    /// It can be changed later for specific needs (like a different timeout for each SMTP command)
+    timeout: Option<Duration>,
+}
+
+/// Builder for the SMTP `SmtpTransport`
+impl SmtpTransportBuilder {
+    /// Creates a new SMTP client
+    ///
+    /// Defaults are:
+    ///
+    /// * No connection reuse
+    /// * No authentication
+    /// * No SMTPUTF8 support
+    /// * A 60 seconds timeout for smtp commands
+    pub fn new<A: ToSocketAddrs>(
+        addr: A,
+        security: ClientSecurity,
+    ) -> Result<SmtpTransportBuilder, Error> {
+        let mut addresses = addr.to_socket_addrs()?;
+
+        match addresses.next() {
+            Some(addr) => Ok(SmtpTransportBuilder {
+                server_addr: addr,
+                security,
+                smtp_utf8: false,
+                credentials: None,
+                connection_reuse: ConnectionReuseParameters::NoReuse,
+                hello_name: ClientId::hostname(),
+                authentication_mechanism: None,
+                timeout: Some(Duration::new(60, 0)),
+            }),
+            None => Err(Error::Resolution),
+        }
+    }
+
+    /// Enable SMTPUTF8 if the server supports it
+    pub fn smtp_utf8(mut self, enabled: bool) -> SmtpTransportBuilder {
+        self.smtp_utf8 = enabled;
+        self
+    }
+
+    /// Set the name used during EHLO
+    pub fn hello_name(mut self, name: ClientId) -> SmtpTransportBuilder {
+        self.hello_name = name;
+        self
+    }
+
+    /// Enable connection reuse
+    pub fn connection_reuse(
+        mut self,
+        parameters: ConnectionReuseParameters,
+    ) -> SmtpTransportBuilder {
+        self.connection_reuse = parameters;
+        self
+    }
+
+    /// Set the client credentials
+    pub fn credentials<S: Into<Credentials>>(mut self, credentials: S) -> SmtpTransportBuilder {
+        self.credentials = Some(credentials.into());
+        self
+    }
+
+    /// Set the authentication mechanism to use
+    pub fn authentication_mechanism(mut self, mechanism: Mechanism) -> SmtpTransportBuilder {
+        self.authentication_mechanism = Some(mechanism);
+        self
+    }
+
+    /// Set the timeout duration
+    pub fn timeout(mut self, timeout: Option<Duration>) -> SmtpTransportBuilder {
+        self.timeout = timeout;
+        self
+    }
+
+    /// Build the SMTP client
+    ///
+    /// It does not connect to the server, but only creates the `SmtpTransport`
+    pub fn build(self) -> SmtpTransport {
+        SmtpTransport::new(self)
+    }
+}
+
+/// Represents the state of a client
+#[derive(Debug)]
+struct State {
+    /// Panic state
+    pub panic: bool,
+    /// Connection reuse counter
+    pub connection_reuse_count: u16,
+}
+
+/// Structure that implements the high level SMTP client
+#[allow(missing_debug_implementations)]
+pub struct SmtpTransport {
+    /// Information about the server
+    /// Value is None before HELO/EHLO
+    server_info: Option<ServerInfo>,
+    /// SmtpTransport variable states
+    state: State,
+    /// Information about the client
+    client_info: SmtpTransportBuilder,
+    /// Low level client
+    client: Client,
+}
+
+macro_rules! try_smtp (
+    ($err: expr, $client: ident) => ({
+        match $err {
+            Ok(val) => val,
+            Err(err) => {
+                if !$client.state.panic {
+                    $client.state.panic = true;
+                    $client.close();
+                }
+                return Err(From::from(err))
+            },
+        }
+    })
+);
+
+impl<'a> SmtpTransport {
+    /// Simple and secure transport, should be used when possible.
+    /// Creates an encrypted transport over submission port, using the provided domain
+    /// to validate TLS certificates.
+    pub fn simple_builder(domain: &str) -> Result<SmtpTransportBuilder, Error> {
+        let mut tls_builder = TlsConnector::builder()?;
+        tls_builder.supported_protocols(DEFAULT_TLS_PROTOCOLS)?;
+
+        let tls_parameters =
+            ClientTlsParameters::new(domain.to_string(), tls_builder.build().unwrap());
+
+        SmtpTransportBuilder::new(
+            (domain, SUBMISSION_PORT),
+            ClientSecurity::Required(tls_parameters),
+        )
+    }
+
+    /// Creates a new configurable builder
+    pub fn builder<A: ToSocketAddrs>(
+        addr: A,
+        security: ClientSecurity,
+    ) -> Result<SmtpTransportBuilder, Error> {
+        SmtpTransportBuilder::new(addr, security)
+    }
+
+    /// Creates a new local SMTP client to port 25
+    pub fn builder_unencrypted_localhost() -> Result<SmtpTransportBuilder, Error> {
+        SmtpTransportBuilder::new(("localhost", SMTP_PORT), ClientSecurity::None)
+    }
+
+    /// Creates a new SMTP client
+    ///
+    /// It does not connect to the server, but only creates the `SmtpTransport`
+    pub fn new(builder: SmtpTransportBuilder) -> SmtpTransport {
+        let client = Client::new();
+
+        SmtpTransport {
+            client,
+            server_info: None,
+            client_info: builder,
+            state: State {
+                panic: false,
+                connection_reuse_count: 0,
+            },
+        }
+    }
+
+    /// Gets the EHLO response and updates server information
+    fn ehlo(&mut self) -> SmtpResult {
+        // Extended Hello
+        let ehlo_response = try_smtp!(
+            self.client.command(EhloCommand::new(ClientId::new(
+                self.client_info.hello_name.to_string()
+            ),)),
+            self
+        );
+
+        self.server_info = Some(try_smtp!(ServerInfo::from_response(&ehlo_response), self));
+
+        // Print server information
+        debug!("server {}", self.server_info.as_ref().unwrap());
+
+        Ok(ehlo_response)
+    }
+
+    /// Reset the client state
+    pub fn close(&mut self) {
+        // Close the SMTP transaction if needed
+        self.client.close();
+
+        // Reset the client state
+        self.server_info = None;
+        self.state.panic = false;
+        self.state.connection_reuse_count = 0;
+    }
+}
+
+impl<'a, T: Read + 'a> EmailTransport<'a, T, SmtpResult> for SmtpTransport {
+    /// Sends an email
+    #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms, cyclomatic_complexity))]
+    fn send<U: SendableEmail<'a, T> + 'a>(&mut self, email: &'a U) -> SmtpResult {
+        // Extract email information
+        let message_id = email.message_id();
+        let envelope = email.envelope();
+
+        // Check if the connection is still available
+        if (self.state.connection_reuse_count > 0) && (!self.client.is_connected()) {
+            self.close();
+        }
+
+        if self.state.connection_reuse_count == 0 {
+            self.client.connect(
+                &self.client_info.server_addr,
+                match self.client_info.security {
+                    ClientSecurity::Wrapper(ref tls_parameters) => Some(tls_parameters),
+                    _ => None,
+                },
+            )?;
+
+            self.client.set_timeout(self.client_info.timeout)?;
+
+            // Log the connection
+            info!("connection established to {}", self.client_info.server_addr);
+
+            self.ehlo()?;
+
+            match (
+                &self.client_info.security.clone(),
+                self.server_info
+                    .as_ref()
+                    .unwrap()
+                    .supports_feature(Extension::StartTls),
+            ) {
+                (&ClientSecurity::Required(_), false) => {
+                    return Err(From::from("Could not encrypt connection, aborting"))
+                }
+                (&ClientSecurity::Opportunistic(_), false) => (),
+                (&ClientSecurity::None, _) => (),
+                (&ClientSecurity::Wrapper(_), _) => (),
+                (&ClientSecurity::Opportunistic(ref tls_parameters), true)
+                | (&ClientSecurity::Required(ref tls_parameters), true) => {
+                    try_smtp!(self.client.command(StarttlsCommand), self);
+                    try_smtp!(self.client.upgrade_tls_stream(tls_parameters), self);
+
+                    debug!("connection encrypted");
+
+                    // Send EHLO again
+                    self.ehlo()?;
+                }
+            }
+
+            if self.client_info.credentials.is_some() {
+                let mut found = false;
+
+                // Compute accepted mechanism
+                let accepted_mechanisms = match self.client_info.authentication_mechanism {
+                    Some(mechanism) => vec![mechanism],
+                    None => {
+                        if self.client.is_encrypted() {
+                            DEFAULT_ENCRYPTED_MECHANISMS.to_vec()
+                        } else {
+                            DEFAULT_UNENCRYPTED_MECHANISMS.to_vec()
+                        }
+                    }
+                };
+
+                for mechanism in accepted_mechanisms {
+                    if self.server_info
+                        .as_ref()
+                        .unwrap()
+                        .supports_auth_mechanism(mechanism)
+                    {
+                        found = true;
+                        try_smtp!(
+                            self.client
+                                .auth(mechanism, self.client_info.credentials.as_ref().unwrap(),),
+                            self
+                        );
+                        break;
+                    }
+                }
+
+                if !found {
+                    info!("No supported authentication mechanisms available");
+                }
+            }
+        }
+
+        // Mail
+        let mut mail_options = vec![];
+
+        if self.server_info
+            .as_ref()
+            .unwrap()
+            .supports_feature(Extension::EightBitMime)
+        {
+            mail_options.push(MailParameter::Body(MailBodyParameter::EightBitMime));
+        }
+
+        if self.server_info
+            .as_ref()
+            .unwrap()
+            .supports_feature(Extension::SmtpUtfEight) && self.client_info.smtp_utf8
+        {
+            mail_options.push(MailParameter::SmtpUtfEight);
+        }
+
+        try_smtp!(
+            self.client
+                .command(MailCommand::new(envelope.from().cloned(), mail_options,)),
+            self
+        );
+
+        // Log the mail command
+        info!(
+            "{}: from=<{}>",
+            message_id,
+            match envelope.from() {
+                Some(address) => address.to_string(),
+                None => "".to_string(),
+            }
+        );
+
+        // Recipient
+        for to_address in envelope.to() {
+            try_smtp!(
+                self.client
+                    .command(RcptCommand::new(to_address.clone(), vec![]),),
+                self
+            );
+            // Log the rcpt command
+            info!("{}: to=<{}>", message_id, to_address);
+        }
+
+        // Data
+        try_smtp!(self.client.command(DataCommand), self);
+
+        // Message content
+        let result = self.client.message(email.message());
+
+        if result.is_ok() {
+            // Increment the connection reuse counter
+            self.state.connection_reuse_count += 1;
+
+            // Log the message
+            info!(
+                "{}: conn_use={}, status=sent ({})",
+                message_id,
+                self.state.connection_reuse_count,
+                result
+                    .as_ref()
+                    .ok()
+                    .unwrap()
+                    .message
+                    .iter()
+                    .next()
+                    .unwrap_or(&"no response".to_string())
+            );
+        }
+
+        // Test if we can reuse the existing connection
+        match self.client_info.connection_reuse {
+            ConnectionReuseParameters::ReuseLimited(limit)
+                if self.state.connection_reuse_count >= limit =>
+            {
+                self.close()
+            }
+            ConnectionReuseParameters::NoReuse => self.close(),
+            _ => (),
+        }
+
+        result
+    }
+}

lettre/src/smtp/response.rs

@@ -1,25 +1,15 @@
 //! SMTP response, containing a mandatory return code and an optional text
 //! message
 
-use crate::transport::smtp::{error, Error};
-use nom::{
-    branch::alt,
-    bytes::streaming::{tag, take_until},
-    combinator::{complete, map},
-    multi::many0,
-    sequence::{preceded, tuple},
-    IResult,
-};
-use std::{
-    fmt::{Display, Formatter, Result},
-    result,
-    str::FromStr,
-    string::ToString,
-};
+use nom::{crlf, ErrorKind as NomErrorKind, IResult as NomResult};
+use nom::simple_errors::Err as NomError;
+use std::fmt::{Display, Formatter, Result};
+use std::result;
+use std::str::{FromStr, from_utf8};
 
 /// First digit indicates severity
 #[derive(PartialEq, Eq, Copy, Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
 pub enum Severity {
     /// 2yx
     PositiveCompletion = 2,
@@ -32,14 +22,14 @@ pub enum Severity {
 }
 
 impl Display for Severity {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+    fn fmt(&self, f: &mut Formatter) -> Result {
         write!(f, "{}", *self as u8)
     }
 }
 
 /// Second digit
 #[derive(PartialEq, Eq, Copy, Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
 pub enum Category {
     /// x0z
     Syntax = 0,
@@ -56,14 +46,14 @@ pub enum Category {
 }
 
 impl Display for Category {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+    fn fmt(&self, f: &mut Formatter) -> Result {
         write!(f, "{}", *self as u8)
     }
 }
 
 /// The detail digit of a response code (third digit)
 #[derive(PartialEq, Eq, Copy, Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
 pub enum Detail {
     #[allow(missing_docs)]
     Zero = 0,
@@ -88,14 +78,14 @@ pub enum Detail {
 }
 
 impl Display for Detail {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+    fn fmt(&self, f: &mut Formatter) -> Result {
         write!(f, "{}", *self as u8)
     }
 }
 
 /// Represents a 3 digit SMTP response code
 #[derive(PartialEq, Eq, Copy, Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
 pub struct Code {
     /// First digit of the response code
     pub severity: Severity,
@@ -106,7 +96,7 @@ pub struct Code {
 }
 
 impl Display for Code {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+    fn fmt(&self, f: &mut Formatter) -> Result {
         write!(f, "{}{}{}", self.severity, self.category, self.detail)
     }
 }
@@ -120,21 +110,13 @@ impl Code {
             detail,
         }
     }
-
-    /// Tells if the response is positive
-    pub fn is_positive(self) -> bool {
-        matches!(
-            self.severity,
-            Severity::PositiveCompletion | Severity::PositiveIntermediate
-        )
-    }
 }
 
 /// Contains an SMTP reply, with separated code and message
 ///
 /// The text message is optional, only the code is mandatory
 #[derive(PartialEq, Eq, Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
 pub struct Response {
     /// Response code
     pub code: Code,
@@ -144,12 +126,14 @@ pub struct Response {
 }
 
 impl FromStr for Response {
-    type Err = Error;
+    type Err = NomError;
 
-    fn from_str(s: &str) -> result::Result<Response, Error> {
-        parse_response(s)
-            .map(|(_, r)| r)
-            .map_err(|e| error::response(e.to_string()))
+    fn from_str(s: &str) -> result::Result<Response, NomError> {
+        match parse_response(s.as_bytes()) {
+            NomResult::Done(_, res) => Ok(res),
+            NomResult::Error(e) => Err(e),
+            NomResult::Incomplete(_) => Err(NomErrorKind::Complete),
+        }
     }
 }
 
@@ -161,7 +145,10 @@ impl Response {
 
     /// Tells if the response is positive
     pub fn is_positive(&self) -> bool {
-        self.code.is_positive()
+        match self.code.severity {
+            Severity::PositiveCompletion | Severity::PositiveIntermediate => true,
+            _ => false,
+        }
     }
 
     /// Tests code equality
@@ -172,7 +159,7 @@ impl Response {
     /// Returns only the first word of the message if possible
     pub fn first_word(&self) -> Option<&str> {
         self.message
-            .first()
+            .get(0)
             .and_then(|line| line.split_whitespace().next())
     }
 
@@ -184,89 +171,101 @@ impl Response {
 
 // Parsers (originally from tokio-smtp)
 
-fn parse_code(i: &str) -> IResult<&str, Code> {
-    let (i, severity) = parse_severity(i)?;
-    let (i, category) = parse_category(i)?;
-    let (i, detail) = parse_detail(i)?;
-    Ok((
-        i,
-        Code {
+named!(
+    parse_code<Code>,
+    map!(
+        tuple!(parse_severity, parse_category, parse_detail),
+        |(severity, category, detail)| Code {
             severity,
             category,
             detail,
-        },
-    ))
-}
+        }
+    )
+);
 
-fn parse_severity(i: &str) -> IResult<&str, Severity> {
-    alt((
-        map(tag("2"), |_| Severity::PositiveCompletion),
-        map(tag("3"), |_| Severity::PositiveIntermediate),
-        map(tag("4"), |_| Severity::TransientNegativeCompletion),
-        map(tag("5"), |_| Severity::PermanentNegativeCompletion),
-    ))(i)
-}
+named!(
+    parse_severity<Severity>,
+    alt!(
+        tag!("2") => { |_| Severity::PositiveCompletion } |
+        tag!("3") => { |_| Severity::PositiveIntermediate } |
+        tag!("4") => { |_| Severity::TransientNegativeCompletion } |
+        tag!("5") => { |_| Severity::PermanentNegativeCompletion }
+    )
+);
 
-fn parse_category(i: &str) -> IResult<&str, Category> {
-    alt((
-        map(tag("0"), |_| Category::Syntax),
-        map(tag("1"), |_| Category::Information),
-        map(tag("2"), |_| Category::Connections),
-        map(tag("3"), |_| Category::Unspecified3),
-        map(tag("4"), |_| Category::Unspecified4),
-        map(tag("5"), |_| Category::MailSystem),
-    ))(i)
-}
+named!(
+    parse_category<Category>,
+    alt!(
+        tag!("0") => { |_| Category::Syntax } |
+        tag!("1") => { |_| Category::Information } |
+        tag!("2") => { |_| Category::Connections } |
+        tag!("3") => { |_| Category::Unspecified3 } |
+        tag!("4") => { |_| Category::Unspecified4 } |
+        tag!("5") => { |_| Category::MailSystem }
+    )
+);
 
-fn parse_detail(i: &str) -> IResult<&str, Detail> {
-    alt((
-        map(tag("0"), |_| Detail::Zero),
-        map(tag("1"), |_| Detail::One),
-        map(tag("2"), |_| Detail::Two),
-        map(tag("3"), |_| Detail::Three),
-        map(tag("4"), |_| Detail::Four),
-        map(tag("5"), |_| Detail::Five),
-        map(tag("6"), |_| Detail::Six),
-        map(tag("7"), |_| Detail::Seven),
-        map(tag("8"), |_| Detail::Eight),
-        map(tag("9"), |_| Detail::Nine),
-    ))(i)
-}
+named!(
+    parse_detail<Detail>,
+    alt!(
+        tag!("0") => { |_| Detail::Zero } |
+        tag!("1") => { |_| Detail::One } |
+        tag!("2") => { |_| Detail::Two } |
+        tag!("3") => { |_| Detail::Three } |
+        tag!("4") => { |_| Detail::Four} |
+        tag!("5") => { |_| Detail::Five } |
+        tag!("6") => { |_| Detail::Six} |
+        tag!("7") => { |_| Detail::Seven } |
+        tag!("8") => { |_| Detail::Eight } |
+        tag!("9") => { |_| Detail::Nine }
+    )
+);
 
-pub(crate) fn parse_response(i: &str) -> IResult<&str, Response> {
-    let (i, lines) = many0(tuple((
-        parse_code,
-        preceded(tag("-"), take_until("\r\n")),
-        tag("\r\n"),
-    )))(i)?;
-    let (i, (last_code, last_line)) =
-        tuple((parse_code, preceded(tag(" "), take_until("\r\n"))))(i)?;
-    let (i, _) = complete(tag("\r\n"))(i)?;
+named!(
+    parse_response<Response>,
+    map_res!(
+        tuple!(
+            // Parse any number of continuation lines.
+            many0!(tuple!(
+                parse_code,
+                preceded!(char!('-'), take_until_and_consume!(b"\r\n".as_ref()))
+            )),
+            // Parse the final line.
+            tuple!(
+                parse_code,
+                terminated!(
+                    opt!(preceded!(char!(' '), take_until!(b"\r\n".as_ref()))),
+                    crlf
+                )
+            )
+        ),
+        |(lines, (last_code, last_line)): (Vec<_>, _)| {
+            // Check that all codes are equal.
+            if !lines.iter().all(|&(ref code, _)| *code == last_code) {
+                return Err(());
+            }
 
-    // Check that all codes are equal.
-    if !lines.iter().all(|&(code, _, _)| code == last_code) {
-        return Err(nom::Err::Failure(nom::error::Error::new(
-            "",
-            nom::error::ErrorKind::Not,
-        )));
-    }
+            // Extract text from lines, and append last line.
+            let mut lines = lines.into_iter().map(|(_, text)| text).collect::<Vec<_>>();
+            if let Some(text) = last_line {
+                lines.push(text);
+            }
 
-    // Extract text from lines, and append last line.
-    let mut lines: Vec<String> = lines.into_iter().map(|(_, text, _)| text.into()).collect();
-    lines.push(last_line.into());
-
-    Ok((
-        i,
-        Response {
-            code: last_code,
-            message: lines,
-        },
-    ))
-}
+            Ok(Response {
+                code: last_code,
+                message: lines
+                    .into_iter()
+                    .map(|line| from_utf8(line).map(|s| s.to_string()))
+                    .collect::<result::Result<Vec<_>, _>>()
+                    .map_err(|_| ())?,
+            })
+        }
+    )
+);
 
 #[cfg(test)]
 mod test {
-    use super::*;
+    use super::{Category, Code, Detail, Response, Severity};
 
     #[test]
     fn test_severity_fmt() {
@@ -334,19 +333,20 @@ mod test {
 
     #[test]
     fn test_response_is_positive() {
-        assert!(Response::new(
-            Code {
-                severity: Severity::PositiveCompletion,
-                category: Category::MailSystem,
-                detail: Detail::Zero,
-            },
-            vec![
-                "me".to_string(),
-                "8BITMIME".to_string(),
-                "SIZE 42".to_string(),
-            ],
-        )
-        .is_positive());
+        assert!(
+            Response::new(
+                Code {
+                    severity: Severity::PositiveCompletion,
+                    category: Category::MailSystem,
+                    detail: Detail::Zero,
+                },
+                vec![
+                    "me".to_string(),
+                    "8BITMIME".to_string(),
+                    "SIZE 42".to_string(),
+                ],
+            ).is_positive()
+        );
         assert!(!Response::new(
             Code {
                 severity: Severity::TransientNegativeCompletion,
@@ -358,25 +358,25 @@ mod test {
                 "8BITMIME".to_string(),
                 "SIZE 42".to_string(),
             ],
-        )
-        .is_positive());
+        ).is_positive());
     }
 
     #[test]
     fn test_response_has_code() {
-        assert!(Response::new(
-            Code {
-                severity: Severity::TransientNegativeCompletion,
-                category: Category::MailSystem,
-                detail: Detail::One,
-            },
-            vec![
-                "me".to_string(),
-                "8BITMIME".to_string(),
-                "SIZE 42".to_string(),
-            ],
-        )
-        .has_code(451));
+        assert!(
+            Response::new(
+                Code {
+                    severity: Severity::TransientNegativeCompletion,
+                    category: Category::MailSystem,
+                    detail: Detail::One,
+                },
+                vec![
+                    "me".to_string(),
+                    "8BITMIME".to_string(),
+                    "SIZE 42".to_string(),
+                ],
+            ).has_code(451)
+        );
         assert!(!Response::new(
             Code {
                 severity: Severity::TransientNegativeCompletion,
@@ -388,8 +388,7 @@ mod test {
                 "8BITMIME".to_string(),
                 "SIZE 42".to_string(),
             ],
-        )
-        .has_code(251));
+        ).has_code(251));
     }
 
     #[test]
@@ -406,8 +405,7 @@ mod test {
                     "8BITMIME".to_string(),
                     "SIZE 42".to_string(),
                 ],
-            )
-            .first_word(),
+            ).first_word(),
             Some("me")
         );
         assert_eq!(
@@ -422,8 +420,7 @@ mod test {
                     "8BITMIME".to_string(),
                     "SIZE 42".to_string(),
                 ],
-            )
-            .first_word(),
+            ).first_word(),
             Some("me")
         );
         assert_eq!(
@@ -434,8 +431,7 @@ mod test {
                     detail: Detail::One,
                 },
                 vec![],
-            )
-            .first_word(),
+            ).first_word(),
             None
         );
         assert_eq!(
@@ -446,8 +442,7 @@ mod test {
                     detail: Detail::One,
                 },
                 vec![" ".to_string()],
-            )
-            .first_word(),
+            ).first_word(),
             None
         );
         assert_eq!(
@@ -458,8 +453,7 @@ mod test {
                     detail: Detail::One,
                 },
                 vec!["  ".to_string()],
-            )
-            .first_word(),
+            ).first_word(),
             None
         );
         assert_eq!(
@@ -470,22 +464,11 @@ mod test {
                     detail: Detail::One,
                 },
                 vec!["".to_string()],
-            )
-            .first_word(),
+            ).first_word(),
             None
         );
     }
 
-    #[test]
-    fn test_response_incomplete() {
-        let raw_response = "250-smtp.example.org\r\n";
-        let res = parse_response(raw_response);
-        match res {
-            Err(nom::Err::Incomplete(_)) => {}
-            _ => panic!("Expected incomplete response, got {:?}", res),
-        }
-    }
-
     #[test]
     fn test_response_first_line() {
         assert_eq!(
@@ -500,8 +483,7 @@ mod test {
                     "8BITMIME".to_string(),
                     "SIZE 42".to_string(),
                 ],
-            )
-            .first_line(),
+            ).first_line(),
             Some("me")
         );
         assert_eq!(
@@ -516,8 +498,7 @@ mod test {
                     "8BITMIME".to_string(),
                     "SIZE 42".to_string(),
                 ],
-            )
-            .first_line(),
+            ).first_line(),
             Some("me mo")
         );
         assert_eq!(
@@ -528,8 +509,7 @@ mod test {
                     detail: Detail::One,
                 },
                 vec![],
-            )
-            .first_line(),
+            ).first_line(),
             None
         );
         assert_eq!(
@@ -540,8 +520,7 @@ mod test {
                     detail: Detail::One,
                 },
                 vec![" ".to_string()],
-            )
-            .first_line(),
+            ).first_line(),
             Some(" ")
         );
         assert_eq!(
@@ -552,8 +531,7 @@ mod test {
                     detail: Detail::One,
                 },
                 vec!["  ".to_string()],
-            )
-            .first_line(),
+            ).first_line(),
             Some("  ")
         );
         assert_eq!(
@@ -564,8 +542,7 @@ mod test {
                     detail: Detail::One,
                 },
                 vec!["".to_string()],
-            )
-            .first_line(),
+            ).first_line(),
             Some("")
         );
     }

lettre/src/smtp/util.rs

@@ -4,11 +4,11 @@ use std::fmt::{Display, Formatter, Result as FmtResult};
 
 /// Encode a string as xtext
 #[derive(Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
 pub struct XText<'a>(pub &'a str);
 
 impl<'a> Display for XText<'a> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+    fn fmt(&self, f: &mut Formatter) -> FmtResult {
         let mut rest = self.0;
         while let Some(idx) = rest.find(|c| c < '!' || c == '+' || c == '=') {
             let (start, end) = rest.split_at(idx);
@@ -34,15 +34,13 @@ mod tests {
 
     #[test]
     fn test() {
-        for (input, expect) in [
+        for (input, expect) in vec![
             ("bjorn", "bjorn"),
             ("bjørn", "bjørn"),
             ("Ø+= ❤️‰", "Ø+2B+3D+20❤️‰"),
             ("+", "+2B"),
-        ]
-        .iter()
-        {
-            assert_eq!(format!("{}", XText(input)), expect.to_string());
+        ] {
+            assert_eq!(format!("{}", XText(input)), expect);
         }
     }
 }

lettre/src/stub/mod.rs

@@ -0,0 +1,44 @@
+//! The stub transport only logs message envelope and drops the content. It can be useful for
+//! testing purposes.
+//!
+
+use EmailTransport;
+use SendableEmail;
+use std::io::Read;
+
+/// This transport logs the message envelope and returns the given response
+#[derive(Debug, Clone, Copy)]
+pub struct StubEmailTransport {
+    response: StubResult,
+}
+
+impl StubEmailTransport {
+    /// Creates a new transport that always returns the given response
+    pub fn new(response: StubResult) -> StubEmailTransport {
+        StubEmailTransport { response }
+    }
+
+    /// Creates a new transport that always returns a success response
+    pub fn new_positive() -> StubEmailTransport {
+        StubEmailTransport { response: Ok(()) }
+    }
+}
+
+/// SMTP result type
+pub type StubResult = Result<(), ()>;
+
+impl<'a, T: Read + 'a> EmailTransport<'a, T, StubResult> for StubEmailTransport {
+    fn send<U: SendableEmail<'a, T>>(&mut self, email: &'a U) -> StubResult {
+        let envelope = email.envelope();
+        info!(
+            "{}: from=<{}> to=<{:?}>",
+            email.message_id(),
+            match envelope.from() {
+                Some(address) => address.to_string(),
+                None => "".to_string(),
+            },
+            envelope.to()
+        );
+        self.response
+    }
+}

lettre/tests/skeptic.rs

@@ -0,0 +1,62 @@
+extern crate glob;
+
+use self::glob::glob;
+use std::env::consts::EXE_EXTENSION;
+use std::env;
+use std::path::Path;
+use std::process::Command;
+
+#[test]
+fn test_readme() {
+    let readme = Path::new(file!())
+        .parent()
+        .unwrap()
+        .parent()
+        .unwrap()
+        .parent()
+        .unwrap()
+        .join("README.md");
+
+    skeptic_test(&readme);
+}
+
+#[test]
+fn book_test() {
+    let mut book_path = env::current_dir().unwrap();
+    book_path.push(
+        Path::new(file!())
+            .parent()
+            .unwrap()
+            .parent()
+            .unwrap()
+            .parent()
+            .unwrap()
+            .join("../website/content/sending-messages"),
+    ); // For some reasons, calling .parent() once more gives us None...
+
+    for md in glob(&format!("{}/*.md", book_path.to_str().unwrap())).unwrap() {
+        skeptic_test(&md.unwrap());
+    }
+}
+
+fn skeptic_test(path: &Path) {
+    let rustdoc = Path::new("rustdoc").with_extension(EXE_EXTENSION);
+    let exe = env::current_exe().unwrap();
+    let depdir = exe.parent().unwrap();
+
+    let mut cmd = Command::new(rustdoc);
+    cmd.args(&["--verbose", "--test"])
+        .arg("-L")
+        .arg(&depdir)
+        .arg(path);
+
+    let result = cmd.spawn()
+        .expect("Failed to spawn process")
+        .wait()
+        .expect("Failed to run process");
+
+    assert!(
+        result.success(),
+        format!("Failed to run rustdoc tests on {:?}", path)
+    );
+}

lettre/tests/transport_file.rs

@@ -0,0 +1,40 @@
+extern crate lettre;
+
+#[cfg(test)]
+#[cfg(feature = "file-transport")]
+mod test {
+
+    use lettre::{EmailTransport, SendableEmail, SimpleSendableEmail};
+    use lettre::file::FileEmailTransport;
+    use std::env::temp_dir;
+    use std::fs::File;
+    use std::fs::remove_file;
+    use std::io::Read;
+
+    #[test]
+    fn file_transport() {
+        let mut sender = FileEmailTransport::new(temp_dir());
+        let email = SimpleSendableEmail::new(
+            "user@localhost".to_string(),
+            &["root@localhost".to_string()],
+            "file_id".to_string(),
+            "Hello file".to_string(),
+        ).unwrap();
+        let result = sender.send(&email);
+        assert!(result.is_ok());
+
+        let message_id = email.message_id();
+        let file = format!("{}/{}.txt", temp_dir().to_str().unwrap(), message_id);
+        let mut f = File::open(file.clone()).unwrap();
+        let mut buffer = String::new();
+        let _ = f.read_to_string(&mut buffer);
+
+        assert_eq!(
+            buffer,
+            "{\"envelope\":{\"forward_path\":[\"root@localhost\"],\"reverse_path\":\"user@localhost\"},\"message_id\":\"file_id\",\"message\":[72,101,108,108,111,32,102,105,108,101]}"
+        );
+
+        remove_file(file).unwrap();
+    }
+
+}

lettre/tests/transport_sendmail.rs

@@ -0,0 +1,25 @@
+extern crate lettre;
+
+#[cfg(test)]
+#[cfg(feature = "sendmail-transport")]
+mod test {
+
+    use lettre::{EmailTransport, SimpleSendableEmail};
+    use lettre::sendmail::SendmailTransport;
+
+    #[test]
+    fn sendmail_transport_simple() {
+        let mut sender = SendmailTransport::new();
+        let email = SimpleSendableEmail::new(
+            "user@localhost".to_string(),
+            &["root@localhost".to_string()],
+            "sendmail_id".to_string(),
+            "Hello sendmail".to_string(),
+        ).unwrap();
+
+        let result = sender.send(&email);
+        println!("{:?}", result);
+        assert!(result.is_ok());
+    }
+
+}

lettre/tests/transport_smtp.rs

@@ -0,0 +1,24 @@
+extern crate lettre;
+
+#[cfg(test)]
+#[cfg(feature = "smtp-transport")]
+mod test {
+
+    use lettre::{ClientSecurity, EmailTransport, SimpleSendableEmail, SmtpTransport};
+
+    #[test]
+    fn smtp_transport_simple() {
+        let mut sender = SmtpTransport::builder("127.0.0.1:2525", ClientSecurity::None)
+            .unwrap()
+            .build();
+        let email = SimpleSendableEmail::new(
+            "user@localhost".to_string(),
+            &["root@localhost".to_string()],
+            "smtp_id".to_string(),
+            "Hello smtp".to_string(),
+        ).unwrap();
+
+        sender.send(&email).unwrap();
+    }
+
+}

lettre/tests/transport_stub.rs

@@ -0,0 +1,19 @@
+extern crate lettre;
+
+use lettre::{EmailTransport, SimpleSendableEmail};
+use lettre::stub::StubEmailTransport;
+
+#[test]
+fn stub_transport() {
+    let mut sender_ok = StubEmailTransport::new_positive();
+    let mut sender_ko = StubEmailTransport::new(Err(()));
+    let email = SimpleSendableEmail::new(
+        "user@localhost".to_string(),
+        &["root@localhost".to_string()],
+        "stub_id".to_string(),
+        "Hello stub".to_string(),
+    ).unwrap();
+
+    sender_ok.send(&email).unwrap();
+    sender_ko.send(&email).unwrap_err();
+}

lettre_email/CHANGELOG.md

@@ -0,0 +1 @@
+../CHANGELOG.md

lettre_email/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+
+name = "lettre_email"
+version = "0.8.2" # remember to update html_root_url
+description = "Email builder"
+readme = "README.md"
+homepage = "http://lettre.at"
+repository = "https://github.com/lettre/lettre"
+license = "MIT"
+authors = ["Alexis Mousset <contact@amousset.me>"]
+categories = ["email"]
+keywords = ["email", "mailer"]
+
+[badges]
+travis-ci = { repository = "lettre/lettre_email" }
+appveyor = { repository = "lettre/lettre_email" }
+maintenance = { status = "actively-developed" }
+is-it-maintained-issue-resolution = { repository = "lettre/lettre_email" }
+is-it-maintained-open-issues = { repository = "lettre/lettre_email" }
+
+[dev-dependencies]
+lettre = { version = "^0.8", path = "../lettre", features = ["smtp-transport"] }
+glob = "0.2"
+
+[dependencies]
+email = "^0.0"
+mime = "^0.3"
+time = "^0.1"
+uuid = { version = "^0.6", features = ["v4"] }
+lettre = { version = "^0.8", path = "../lettre", default-features = false }
+base64 = "^0.9"

lettre_email/LICENSE

@@ -0,0 +1 @@
+../LICENSE

lettre_email/README.md

@@ -0,0 +1 @@
+../README.md

lettre_email/examples/smtp.rs

@@ -0,0 +1,35 @@
+extern crate lettre;
+extern crate lettre_email;
+extern crate mime;
+
+use lettre::{EmailTransport, SmtpTransport};
+use lettre_email::EmailBuilder;
+use std::path::Path;
+
+fn main() {
+    let email = EmailBuilder::new()
+        // Addresses can be specified by the tuple (email, alias)
+        .to(("user@example.org", "Firstname Lastname"))
+        // ... or by an address only
+        .from("user@example.com")
+        .subject("Hi, Hello world")
+        .text("Hello world.")
+        .attachment(Path::new("Cargo.toml"), None, &mime::TEXT_PLAIN).unwrap()
+        .build()
+        .unwrap();
+
+    // Open a local connection on port 25
+    let mut mailer = SmtpTransport::builder_unencrypted_localhost()
+        .unwrap()
+        .build();
+    // Send the email
+    let result = mailer.send(&email);
+
+    if result.is_ok() {
+        println!("Email sent");
+    } else {
+        println!("Could not send email: {:?}", result);
+    }
+
+    assert!(result.is_ok());
+}

lettre_email/src/error.rs

@@ -0,0 +1,47 @@
+//! Error and result type for emails
+
+use self::Error::*;
+use std::error::Error as StdError;
+use std::fmt::{self, Display, Formatter};
+use std::io;
+
+use lettre;
+
+/// An enum of all error kinds.
+#[derive(Debug)]
+pub enum Error {
+    /// Envelope error
+    Email(lettre::Error),
+    /// Unparseable filename for attachment
+    CannotParseFilename,
+    /// IO error
+    Io(io::Error),
+}
+
+impl Display for Error {
+    fn fmt(&self, fmt: &mut Formatter) -> Result<(), fmt::Error> {
+        fmt.write_str(self.description())
+    }
+}
+
+impl StdError for Error {
+    fn description(&self) -> &str {
+        match *self {
+            Email(ref err) => err.description(),
+            CannotParseFilename => "the attachment filename could not be parsed",
+            Io(ref err) => err.description(),
+        }
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(err: io::Error) -> Error {
+        Io(err)
+    }
+}
+
+impl From<lettre::Error> for Error {
+    fn from(err: lettre::Error) -> Error {
+        Email(err)
+    }
+}

lettre_email/src/lib.rs

@@ -0,0 +1,947 @@
+//! Lettre is a mailer written in Rust. lettre_email provides a simple email builder.
+//!
+
+#![doc(html_root_url = "https://docs.rs/lettre_email/0.8.2")]
+#![deny(missing_docs, missing_debug_implementations, missing_copy_implementations, trivial_casts,
+        trivial_numeric_casts, unsafe_code, unstable_features, unused_import_braces,
+        unused_qualifications)]
+
+extern crate base64;
+extern crate email as email_format;
+extern crate lettre;
+extern crate mime;
+extern crate time;
+extern crate uuid;
+
+pub mod error;
+
+pub use email_format::{Address, Header, Mailbox, MimeMessage, MimeMultipartType};
+use error::Error;
+use lettre::{EmailAddress, Envelope, Error as EmailError, SendableEmail};
+use mime::Mime;
+use std::fs::File;
+use std::io::Read;
+use std::path::Path;
+use time::{now, Tm};
+use uuid::Uuid;
+use std::str::FromStr;
+
+/// Converts an address or an address with an alias to a `Header`
+pub trait IntoHeader {
+    /// Converts to a `Header` struct
+    fn into_header(self) -> Header;
+}
+
+impl IntoHeader for Header {
+    fn into_header(self) -> Header {
+        self
+    }
+}
+
+impl<S: Into<String>, T: Into<String>> IntoHeader for (S, T) {
+    fn into_header(self) -> Header {
+        let (name, value) = self;
+        Header::new(name.into(), value.into())
+    }
+}
+
+/// Converts an address or an address with an alias to a `Mailbox`
+pub trait IntoMailbox {
+    /// Converts to a `Mailbox` struct
+    fn into_mailbox(self) -> Mailbox;
+}
+
+impl IntoMailbox for Mailbox {
+    fn into_mailbox(self) -> Mailbox {
+        self
+    }
+}
+
+impl<'a> IntoMailbox for &'a str {
+    fn into_mailbox(self) -> Mailbox {
+        Mailbox::new(self.into())
+    }
+}
+
+impl IntoMailbox for String {
+    fn into_mailbox(self) -> Mailbox {
+        Mailbox::new(self)
+    }
+}
+
+impl<S: Into<String>, T: Into<String>> IntoMailbox for (S, T) {
+    fn into_mailbox(self) -> Mailbox {
+        let (address, alias) = self;
+        Mailbox::new_with_name(alias.into(), address.into())
+    }
+}
+
+/// Can be transformed to a sendable email
+pub trait IntoEmail {
+    /// Builds an email
+    fn into_email(self) -> Result<Email, Error>;
+}
+
+impl IntoEmail for SimpleEmail {
+    fn into_email(self) -> Result<Email, Error> {
+        let mut builder = EmailBuilder::new();
+
+        if self.from.is_some() {
+            builder.add_from(self.from.unwrap());
+        }
+
+        for to_address in self.to {
+            builder.add_to(to_address.into_mailbox());
+        }
+
+        for cc_address in self.cc {
+            builder.add_cc(cc_address.into_mailbox());
+        }
+
+        if self.reply_to.is_some() {
+            builder.add_reply_to(self.reply_to.unwrap().into_mailbox());
+        }
+
+        if self.subject.is_some() {
+            builder.set_subject(self.subject.unwrap());
+        }
+
+        // No date for now
+
+        match (self.text, self.html) {
+            (Some(text), Some(html)) => builder.set_alternative(html, text),
+            (Some(text), None) => builder.set_text(text),
+            (None, Some(html)) => builder.set_html(html),
+            (None, None) => (),
+        }
+
+        for header in self.headers {
+            builder.add_header(header.into_header());
+        }
+
+        builder.build()
+    }
+}
+
+/// Simple representation of an email, useful for some transports
+#[derive(PartialEq, Eq, Clone, Debug, Default)]
+pub struct SimpleEmail {
+    from: Option<Mailbox>,
+    to: Vec<Mailbox>,
+    cc: Vec<Mailbox>,
+    bcc: Vec<Mailbox>,
+    reply_to: Option<Mailbox>,
+    subject: Option<String>,
+    date: Option<Tm>,
+    html: Option<String>,
+    text: Option<String>,
+    attachments: Vec<String>,
+    headers: Vec<Header>,
+}
+
+impl SimpleEmail {
+    /// Adds a generic header
+    pub fn header<A: IntoHeader>(mut self, header: A) -> SimpleEmail {
+        self.add_header(header);
+        self
+    }
+
+    /// Adds a generic header
+    pub fn add_header<A: IntoHeader>(&mut self, header: A) {
+        self.headers.push(header.into_header());
+    }
+
+    /// Adds a `From` header and stores the sender address
+    pub fn from<A: IntoMailbox>(mut self, address: A) -> SimpleEmail {
+        self.add_from(address);
+        self
+    }
+
+    /// Adds a `From` header and stores the sender address
+    pub fn add_from<A: IntoMailbox>(&mut self, address: A) {
+        self.from = Some(address.into_mailbox());
+    }
+
+    /// Adds a `To` header and stores the recipient address
+    pub fn to<A: IntoMailbox>(mut self, address: A) -> SimpleEmail {
+        self.add_to(address);
+        self
+    }
+
+    /// Adds a `To` header and stores the recipient address
+    pub fn add_to<A: IntoMailbox>(&mut self, address: A) {
+        self.to.push(address.into_mailbox());
+    }
+
+    /// Adds a `Cc` header and stores the recipient address
+    pub fn cc<A: IntoMailbox>(mut self, address: A) -> SimpleEmail {
+        self.add_cc(address);
+        self
+    }
+
+    /// Adds a `Cc` header and stores the recipient address
+    pub fn add_cc<A: IntoMailbox>(&mut self, address: A) {
+        self.cc.push(address.into_mailbox());
+    }
+
+    /// Adds a `Bcc` header and stores the recipient address
+    pub fn bcc<A: IntoMailbox>(mut self, address: A) -> SimpleEmail {
+        self.add_bcc(address);
+        self
+    }
+
+    /// Adds a `Bcc` header and stores the recipient address
+    pub fn add_bcc<A: IntoMailbox>(&mut self, address: A) {
+        self.bcc.push(address.into_mailbox());
+    }
+
+    /// Adds a `Reply-To` header
+    pub fn reply_to<A: IntoMailbox>(mut self, address: A) -> SimpleEmail {
+        self.add_reply_to(address);
+        self
+    }
+
+    /// Adds a `Reply-To` header
+    pub fn add_reply_to<A: IntoMailbox>(&mut self, address: A) {
+        self.reply_to = Some(address.into_mailbox());
+    }
+
+    /// Adds a `Subject` header
+    pub fn subject<S: Into<String>>(mut self, subject: S) -> SimpleEmail {
+        self.set_subject(subject);
+        self
+    }
+
+    /// Adds a `Subject` header
+    pub fn set_subject<S: Into<String>>(&mut self, subject: S) {
+        self.subject = Some(subject.into());
+    }
+
+    /// Adds a `Date` header with the given date
+    pub fn date(mut self, date: Tm) -> SimpleEmail {
+        self.set_date(date);
+        self
+    }
+
+    /// Adds a `Date` header with the given date
+    pub fn set_date(&mut self, date: Tm) {
+        self.date = Some(date);
+    }
+
+    /// Adds an attachment to the message
+    pub fn attachment<S: Into<String>>(mut self, path: S) -> SimpleEmail {
+        self.add_attachment(path);
+        self
+    }
+
+    /// Adds an attachment to the message
+    pub fn add_attachment<S: Into<String>>(&mut self, path: S) {
+        self.attachments.push(path.into());
+    }
+
+    /// Sets the email body to plain text content
+    pub fn text<S: Into<String>>(mut self, body: S) -> SimpleEmail {
+        self.set_text(body);
+        self
+    }
+
+    /// Sets the email body to plain text content
+    pub fn set_text<S: Into<String>>(&mut self, body: S) {
+        self.text = Some(body.into());
+    }
+
+    /// Sets the email body to HTML content
+    pub fn html<S: Into<String>>(mut self, body: S) -> SimpleEmail {
+        self.set_html(body);
+        self
+    }
+
+    /// Sets the email body to HTML content
+    pub fn set_html<S: Into<String>>(&mut self, body: S) {
+        self.html = Some(body.into());
+    }
+}
+
+/// Builds a `MimeMessage` structure
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct PartBuilder {
+    /// Message
+    message: MimeMessage,
+}
+
+impl Default for PartBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Builds an `Email` structure
+#[derive(PartialEq, Eq, Clone, Debug, Default)]
+pub struct EmailBuilder {
+    /// Message
+    message: PartBuilder,
+    /// The recipients' addresses for the mail header
+    to_header: Vec<Address>,
+    /// The sender addresses for the mail header
+    from_header: Vec<Address>,
+    /// The Cc addresses for the mail header
+    cc_header: Vec<Address>,
+    /// The Bcc addresses for the mail header
+    bcc_header: Vec<Address>,
+    /// The Reply-To addresses for the mail header
+    reply_to_header: Vec<Address>,
+    /// The sender address for the mail header
+    sender_header: Option<Mailbox>,
+    /// The envelope
+    envelope: Option<Envelope>,
+    /// Date issued
+    date_issued: bool,
+}
+
+/// Simple email representation
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct Email {
+    /// Message
+    message: Vec<u8>,
+    /// Envelope
+    envelope: Envelope,
+    /// Message-ID
+    message_id: Uuid,
+}
+
+impl PartBuilder {
+    /// Creates a new empty part
+    pub fn new() -> PartBuilder {
+        PartBuilder {
+            message: MimeMessage::new_blank_message(),
+        }
+    }
+
+    /// Adds a generic header
+    pub fn header<A: IntoHeader>(mut self, header: A) -> PartBuilder {
+        self.add_header(header);
+        self
+    }
+
+    /// Adds a generic header
+    pub fn add_header<A: IntoHeader>(&mut self, header: A) {
+        self.message.headers.insert(header.into_header());
+    }
+
+    /// Sets the body
+    pub fn body<S: Into<String>>(mut self, body: S) -> PartBuilder {
+        self.set_body(body);
+        self
+    }
+
+    /// Sets the body
+    pub fn set_body<S: Into<String>>(&mut self, body: S) {
+        self.message.body = body.into();
+    }
+
+    /// Defines a `MimeMultipartType` value
+    pub fn message_type(mut self, mime_type: MimeMultipartType) -> PartBuilder {
+        self.set_message_type(mime_type);
+        self
+    }
+
+    /// Defines a `MimeMultipartType` value
+    pub fn set_message_type(&mut self, mime_type: MimeMultipartType) {
+        self.message.message_type = Some(mime_type);
+    }
+
+    /// Adds a `ContentType` header with the given MIME type
+    pub fn content_type(mut self, content_type: &Mime) -> PartBuilder {
+        self.set_content_type(content_type);
+        self
+    }
+
+    /// Adds a `ContentType` header with the given MIME type
+    pub fn set_content_type(&mut self, content_type: &Mime) {
+        self.add_header(("Content-Type", format!("{}", content_type).as_ref()));
+    }
+
+    /// Adds a child part
+    pub fn child(mut self, child: MimeMessage) -> PartBuilder {
+        self.add_child(child);
+        self
+    }
+
+    /// Adds a child part
+    pub fn add_child(&mut self, child: MimeMessage) {
+        self.message.children.push(child);
+    }
+
+    /// Gets built `MimeMessage`
+    pub fn build(mut self) -> MimeMessage {
+        self.message.update_headers();
+        self.message
+    }
+}
+
+impl EmailBuilder {
+    /// Creates a new empty email
+    pub fn new() -> EmailBuilder {
+        EmailBuilder {
+            message: PartBuilder::new(),
+            to_header: vec![],
+            from_header: vec![],
+            cc_header: vec![],
+            bcc_header: vec![],
+            reply_to_header: vec![],
+            sender_header: None,
+            envelope: None,
+            date_issued: false,
+        }
+    }
+
+    /// Sets the email body
+    pub fn body<S: Into<String>>(mut self, body: S) -> EmailBuilder {
+        self.message.set_body(body);
+        self
+    }
+
+    /// Sets the email body
+    pub fn set_body<S: Into<String>>(&mut self, body: S) {
+        self.message.set_body(body);
+    }
+
+    /// Add a generic header
+    pub fn header<A: IntoHeader>(mut self, header: A) -> EmailBuilder {
+        self.message.add_header(header);
+        self
+    }
+
+    /// Add a generic header
+    pub fn add_header<A: IntoHeader>(&mut self, header: A) {
+        self.message.add_header(header);
+    }
+
+    /// Adds a `From` header and stores the sender address
+    pub fn from<A: IntoMailbox>(mut self, address: A) -> EmailBuilder {
+        self.add_from(address);
+        self
+    }
+
+    /// Adds a `From` header and stores the sender address
+    pub fn add_from<A: IntoMailbox>(&mut self, address: A) {
+        let mailbox = address.into_mailbox();
+        self.from_header.push(Address::Mailbox(mailbox));
+    }
+
+    /// Adds a `To` header and stores the recipient address
+    pub fn to<A: IntoMailbox>(mut self, address: A) -> EmailBuilder {
+        self.add_to(address);
+        self
+    }
+
+    /// Adds a `To` header and stores the recipient address
+    pub fn add_to<A: IntoMailbox>(&mut self, address: A) {
+        let mailbox = address.into_mailbox();
+        self.to_header.push(Address::Mailbox(mailbox));
+    }
+
+    /// Adds a `Cc` header and stores the recipient address
+    pub fn cc<A: IntoMailbox>(mut self, address: A) -> EmailBuilder {
+        self.add_cc(address);
+        self
+    }
+
+    /// Adds a `Cc` header and stores the recipient address
+    pub fn add_cc<A: IntoMailbox>(&mut self, address: A) {
+        let mailbox = address.into_mailbox();
+        self.cc_header.push(Address::Mailbox(mailbox));
+    }
+
+    /// Adds a `Bcc` header and stores the recipient address
+    pub fn bcc<A: IntoMailbox>(mut self, address: A) -> EmailBuilder {
+        self.add_bcc(address);
+        self
+    }
+
+    /// Adds a `Bcc` header and stores the recipient address
+    pub fn add_bcc<A: IntoMailbox>(&mut self, address: A) {
+        let mailbox = address.into_mailbox();
+        self.bcc_header.push(Address::Mailbox(mailbox));
+    }
+
+    /// Adds a `Reply-To` header
+    pub fn reply_to<A: IntoMailbox>(mut self, address: A) -> EmailBuilder {
+        self.add_reply_to(address);
+        self
+    }
+
+    /// Adds a `Reply-To` header
+    pub fn add_reply_to<A: IntoMailbox>(&mut self, address: A) {
+        let mailbox = address.into_mailbox();
+        self.reply_to_header.push(Address::Mailbox(mailbox));
+    }
+
+    /// Adds a `Sender` header
+    pub fn sender<A: IntoMailbox>(mut self, address: A) -> EmailBuilder {
+        self.set_sender(address);
+        self
+    }
+
+    /// Adds a `Sender` header
+    pub fn set_sender<A: IntoMailbox>(&mut self, address: A) {
+        let mailbox = address.into_mailbox();
+        self.sender_header = Some(mailbox);
+    }
+
+    /// Adds a `Subject` header
+    pub fn subject<S: Into<String>>(mut self, subject: S) -> EmailBuilder {
+        self.set_subject(subject);
+        self
+    }
+
+    /// Adds a `Subject` header
+    pub fn set_subject<S: Into<String>>(&mut self, subject: S) {
+        self.message
+            .add_header(("Subject".to_string(), subject.into()));
+    }
+
+    /// Adds a `Date` header with the given date
+    pub fn date(mut self, date: &Tm) -> EmailBuilder {
+        self.set_date(date);
+        self
+    }
+
+    /// Adds a `Date` header with the given date
+    pub fn set_date(&mut self, date: &Tm) {
+        self.message
+            .add_header(("Date", Tm::rfc822z(date).to_string()));
+        self.date_issued = true;
+    }
+
+    /// Adds an attachment to the email
+    pub fn attachment(
+        mut self,
+        path: &Path,
+        filename: Option<&str>,
+        content_type: &Mime,
+    ) -> Result<EmailBuilder, Error> {
+        self.set_attachment(path, filename, content_type)?;
+        Ok(self)
+    }
+
+    /// Adds an attachment to the email
+    /// If filename is not provided, the name of the file will be used.
+    pub fn set_attachment(
+        &mut self,
+        path: &Path,
+        filename: Option<&str>,
+        content_type: &Mime,
+    ) -> Result<(), Error> {
+        let file = File::open(path);
+        let body = match file {
+            Ok(mut f) => {
+                let mut data = Vec::new();
+                let read = f.read_to_end(&mut data);
+                match read {
+                    Ok(_) => data,
+                    Err(e) => {
+                        return Err(From::from(e));
+                    }
+                }
+            }
+            Err(e) => {
+                return Err(From::from(e));
+            }
+        };
+
+        let actual_filename = match filename {
+            Some(name) => name,
+            None => match path.file_name() {
+                Some(name) => match name.to_str() {
+                    Some(name) => name,
+                    None => return Err(Error::CannotParseFilename),
+                },
+                None => return Err(Error::CannotParseFilename),
+            },
+        };
+
+        let encoded_body = base64::encode(&body);
+        let content = PartBuilder::new()
+            .body(encoded_body)
+            .header((
+                "Content-Disposition",
+                format!("attachment; filename=\"{}\"", actual_filename),
+            ))
+            .header(("Content-Type", content_type.to_string()))
+            .header(("Content-Transfer-Encoding", "base64"))
+            .build();
+
+        self.set_message_type(MimeMultipartType::Mixed);
+        self.add_child(content);
+
+        Ok(())
+    }
+
+    /// Set the message type
+    pub fn message_type(mut self, message_type: MimeMultipartType) -> EmailBuilder {
+        self.set_message_type(message_type);
+        self
+    }
+
+    /// Set the message type
+    pub fn set_message_type(&mut self, message_type: MimeMultipartType) {
+        self.message.set_message_type(message_type);
+    }
+
+    /// Adds a child
+    pub fn child(mut self, child: MimeMessage) -> EmailBuilder {
+        self.add_child(child);
+        self
+    }
+
+    /// Adds a child
+    pub fn add_child(&mut self, child: MimeMessage) {
+        self.message.add_child(child);
+    }
+
+    /// Sets the email body to plain text content
+    pub fn text<S: Into<String>>(mut self, body: S) -> EmailBuilder {
+        self.set_text(body);
+        self
+    }
+
+    /// Sets the email body to plain text content
+    pub fn set_text<S: Into<String>>(&mut self, body: S) {
+        let text = PartBuilder::new()
+            .body(body)
+            .header((
+                "Content-Type",
+                format!("{}", mime::TEXT_PLAIN_UTF_8).as_ref(),
+            ))
+            .build();
+        self.add_child(text);
+    }
+
+    /// Sets the email body to HTML content
+    pub fn html<S: Into<String>>(mut self, body: S) -> EmailBuilder {
+        self.set_html(body);
+        self
+    }
+
+    /// Sets the email body to HTML content
+    pub fn set_html<S: Into<String>>(&mut self, body: S) {
+        let html = PartBuilder::new()
+            .body(body)
+            .header((
+                "Content-Type",
+                format!("{}", mime::TEXT_HTML_UTF_8).as_ref(),
+            ))
+            .build();
+        self.add_child(html);
+    }
+
+    /// Sets the email content
+    pub fn alternative<S: Into<String>, T: Into<String>>(
+        mut self,
+        body_html: S,
+        body_text: T,
+    ) -> EmailBuilder {
+        self.set_alternative(body_html, body_text);
+        self
+    }
+
+    /// Sets the email content
+    pub fn set_alternative<S: Into<String>, T: Into<String>>(
+        &mut self,
+        body_html: S,
+        body_text: T,
+    ) {
+        let mut alternate = PartBuilder::new();
+        alternate.set_message_type(MimeMultipartType::Alternative);
+
+        let text = PartBuilder::new()
+            .body(body_text)
+            .header((
+                "Content-Type",
+                format!("{}", mime::TEXT_PLAIN_UTF_8).as_ref(),
+            ))
+            .build();
+
+        let html = PartBuilder::new()
+            .body(body_html)
+            .header((
+                "Content-Type",
+                format!("{}", mime::TEXT_HTML_UTF_8).as_ref(),
+            ))
+            .build();
+
+        alternate.add_child(text);
+        alternate.add_child(html);
+
+        self.set_message_type(MimeMultipartType::Mixed);
+        self.add_child(alternate.build());
+    }
+
+    /// Sets the envelope for manual destination control
+    /// If this function is not called, the envelope will be calculated
+    /// from the "to" and "cc" addresses you set.
+    pub fn envelope(mut self, envelope: Envelope) -> EmailBuilder {
+        self.set_envelope(envelope);
+        self
+    }
+
+    /// Sets the envelope for manual destination control
+    /// If this function is not called, the envelope will be calculated
+    /// from the "to" and "cc" addresses you set.
+    pub fn set_envelope(&mut self, envelope: Envelope) {
+        self.envelope = Some(envelope);
+    }
+
+    /// Builds the Email
+    pub fn build(mut self) -> Result<Email, Error> {
+        // If there are multiple addresses in "From", the "Sender" is required.
+        if self.from_header.len() >= 2 && self.sender_header.is_none() {
+            // So, we must find something to put as Sender.
+            for possible_sender in &self.from_header {
+                // Only a mailbox can be used as sender, not Address::Group.
+                if let Address::Mailbox(ref mbx) = *possible_sender {
+                    self.sender_header = Some(mbx.clone());
+                    break;
+                }
+            }
+            // Address::Group is not yet supported, so the line below will never panic.
+            // If groups are supported one day, add another Error for this case
+            //  and return it here, if sender_header is still None at this point.
+            assert!(self.sender_header.is_some());
+        }
+        // Add the sender header, if any.
+        if let Some(ref v) = self.sender_header {
+            self.message.add_header(("Sender", v.to_string().as_ref()));
+        }
+        // Calculate the envelope
+        let envelope = match self.envelope {
+            Some(e) => e,
+            None => {
+                // we need to generate the envelope
+                let mut e = Envelope::builder();
+                // add all receivers in to_header and cc_header
+                for receiver in self.to_header
+                    .iter()
+                    .chain(self.cc_header.iter())
+                    .chain(self.bcc_header.iter())
+                {
+                    match *receiver {
+                        Address::Mailbox(ref m) => e.add_to(EmailAddress::from_str(&m.address)?),
+                        Address::Group(_, ref ms) => for m in ms.iter() {
+                            e.add_to(EmailAddress::from_str(&m.address.clone())?);
+                        },
+                    }
+                }
+                e.set_from(EmailAddress::from_str(&match self.sender_header {
+                    Some(x) => x.address.clone(), // if we have a sender_header, use it
+                    None => {
+                        // use a from header
+                        debug_assert!(self.from_header.len() <= 1); // else we'd have sender_header
+                        match self.from_header.first() {
+                            Some(a) => match *a {
+                                // if we have a from header
+                                Address::Mailbox(ref mailbox) => mailbox.address.clone(), // use it
+                                Address::Group(_, ref mailbox_list) => match mailbox_list.first() {
+                                    // if it's an author group, use the first author
+                                    Some(mailbox) => mailbox.address.clone(),
+                                    // for an empty author group (the rarest of the rare cases)
+                                    None => return Err(Error::Email(EmailError::MissingFrom)), // empty envelope sender
+                                },
+                            },
+                            // if we don't have a from header
+                            None => return Err(Error::Email(EmailError::MissingFrom)), // empty envelope sender
+                        }
+                    }
+                })?);
+                e.build()?
+            }
+        };
+        // Add the collected addresses as mailbox-list all at once.
+        // The unwraps are fine because the conversions for Vec<Address> never errs.
+        if !self.to_header.is_empty() {
+            self.message
+                .add_header(Header::new_with_value("To".into(), self.to_header).unwrap());
+        }
+        if !self.from_header.is_empty() {
+            self.message
+                .add_header(Header::new_with_value("From".into(), self.from_header).unwrap());
+        } else {
+            return Err(Error::Email(EmailError::MissingFrom));
+        }
+        if !self.cc_header.is_empty() {
+            self.message
+                .add_header(Header::new_with_value("Cc".into(), self.cc_header).unwrap());
+        }
+        if !self.bcc_header.is_empty() {
+            self.message
+                .add_header(Header::new_with_value("Bcc".into(), self.bcc_header).unwrap());
+        }
+        if !self.reply_to_header.is_empty() {
+            self.message.add_header(
+                Header::new_with_value("Reply-To".into(), self.reply_to_header).unwrap(),
+            );
+        }
+
+        if !self.date_issued {
+            self.message
+                .add_header(("Date", Tm::rfc822z(&now()).to_string().as_ref()));
+        }
+
+        self.message.add_header(("MIME-Version", "1.0"));
+
+        let message_id = Uuid::new_v4();
+
+        if let Ok(header) = Header::new_with_value(
+            "Message-ID".to_string(),
+            format!("<{}.lettre@localhost>", message_id),
+        ) {
+            self.message.add_header(header)
+        }
+
+        Ok(Email {
+            message: self.message.build().as_string().into_bytes(),
+            envelope,
+            message_id,
+        })
+    }
+}
+
+impl<'a> SendableEmail<'a, &'a [u8]> for Email {
+    fn envelope(&self) -> Envelope {
+        self.envelope.clone()
+    }
+
+    fn message_id(&self) -> String {
+        self.message_id.to_string()
+    }
+
+    fn message(&'a self) -> Box<&[u8]> {
+        Box::new(self.message.as_slice())
+    }
+}
+
+/// Email sendable by any type of client, giving access to all fields
+pub trait ExtractableEmail {
+    /// From address
+    fn from_address(&self) -> Option<String>;
+    /// To addresses
+    fn to_addresses(&self) -> Vec<String>;
+    /// Cc addresses
+    fn cc_addresses(&self) -> Vec<String>;
+    /// Bcc addresses
+    fn bcc_addresses(&self) -> Vec<String>;
+    /// Replay-To addresses
+    fn reply_to_address(&self) -> String;
+    /// Subject
+    fn subject(&self) -> String;
+    /// Message ID
+    fn message_id(&self) -> String;
+    /// Other Headers
+    fn headers(&self) -> Vec<String>;
+    /// html content
+    fn html(self) -> String;
+    /// text content
+    fn text(self) -> String;
+}
+
+#[cfg(test)]
+mod test {
+    use super::EmailBuilder;
+    use lettre::{EmailAddress, SendableEmail};
+    use time::now;
+
+    #[test]
+    fn test_multiple_from() {
+        let email_builder = EmailBuilder::new();
+        let date_now = now();
+        let email = email_builder
+            .to("anna@example.com")
+            .from("dieter@example.com")
+            .from("joachim@example.com")
+            .date(&date_now)
+            .subject("Invitation")
+            .body("We invite you!")
+            .build()
+            .unwrap();
+        assert_eq!(
+            format!("{}", String::from_utf8_lossy(email.message().as_ref())),
+            format!(
+                "Date: {}\r\nSubject: Invitation\r\nSender: \
+                 <dieter@example.com>\r\nTo: <anna@example.com>\r\nFrom: \
+                 <dieter@example.com>, <joachim@example.com>\r\nMIME-Version: \
+                 1.0\r\nMessage-ID: <{}.lettre@localhost>\r\n\r\nWe invite you!\r\n",
+                date_now.rfc822z(),
+                email.message_id()
+            )
+        );
+    }
+
+    #[test]
+    fn test_email_builder() {
+        let email_builder = EmailBuilder::new();
+        let date_now = now();
+
+        let email = email_builder
+            .to("user@localhost")
+            .from("user@localhost")
+            .cc(("cc@localhost", "Alias"))
+            .bcc("bcc@localhost")
+            .reply_to("reply@localhost")
+            .sender("sender@localhost")
+            .body("Hello World!")
+            .date(&date_now)
+            .subject("Hello")
+            .header(("X-test", "value"))
+            .build()
+            .unwrap();
+
+        assert_eq!(
+            format!("{}", String::from_utf8_lossy(email.message().as_ref())),
+            format!(
+                "Date: {}\r\nSubject: Hello\r\nX-test: value\r\nSender: \
+                 <sender@localhost>\r\nTo: <user@localhost>\r\nFrom: \
+                 <user@localhost>\r\nCc: \"Alias\" <cc@localhost>\r\n\
+                 Bcc: <bcc@localhost>\r\nReply-To: <reply@localhost>\r\n\
+                 MIME-Version: 1.0\r\nMessage-ID: \
+                 <{}.lettre@localhost>\r\n\r\nHello World!\r\n",
+                date_now.rfc822z(),
+                email.message_id()
+            )
+        );
+    }
+
+    #[test]
+    fn test_email_sendable() {
+        let email_builder = EmailBuilder::new();
+        let date_now = now();
+
+        let email = email_builder
+            .to("user@localhost")
+            .from("user@localhost")
+            .cc(("cc@localhost", "Alias"))
+            .bcc("bcc@localhost")
+            .reply_to("reply@localhost")
+            .sender("sender@localhost")
+            .body("Hello World!")
+            .date(&date_now)
+            .subject("Hello")
+            .header(("X-test", "value"))
+            .build()
+            .unwrap();
+
+        assert_eq!(
+            email.envelope().from().unwrap().to_string(),
+            "sender@localhost".to_string()
+        );
+        assert_eq!(
+            email.envelope().to(),
+            vec![
+                EmailAddress::new("user@localhost".to_string()).unwrap(),
+                EmailAddress::new("cc@localhost".to_string()).unwrap(),
+                EmailAddress::new("bcc@localhost".to_string()).unwrap(),
+            ].as_slice()
+        );
+    }
+
+}

lettre_email/tests/skeptic.rs

@@ -0,0 +1,48 @@
+extern crate glob;
+
+use self::glob::glob;
+use std::env::consts::EXE_EXTENSION;
+use std::env;
+use std::path::Path;
+use std::process::Command;
+
+#[test]
+fn book_test() {
+    let mut book_path = env::current_dir().unwrap();
+    book_path.push(
+        Path::new(file!())
+            .parent()
+            .unwrap()
+            .parent()
+            .unwrap()
+            .parent()
+            .unwrap()
+            .join("../website/content/creating-messages"),
+    ); // For some reasons, calling .parent() once more gives us None...
+
+    for md in glob(&format!("{}/*.md", book_path.to_str().unwrap())).unwrap() {
+        skeptic_test(&md.unwrap());
+    }
+}
+
+fn skeptic_test(path: &Path) {
+    let rustdoc = Path::new("rustdoc").with_extension(EXE_EXTENSION);
+    let exe = env::current_exe().unwrap();
+    let depdir = exe.parent().unwrap();
+
+    let mut cmd = Command::new(rustdoc);
+    cmd.args(&["--verbose", "--test"])
+        .arg("-L")
+        .arg(&depdir)
+        .arg(path);
+
+    let result = cmd.spawn()
+        .expect("Failed to spawn process")
+        .wait()
+        .expect("Failed to run process");
+
+    assert!(
+        result.success(),
+        format!("Failed to run rustdoc tests on {:?}!", path)
+    );
+}

src/address/envelope.rs

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

src/address/mod.rs

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

src/address/serde.rs

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

src/address/types.rs

@@ -1,265 +0,0 @@
-//! Representation of an email address
-
-use idna::domain_to_ascii;
-use once_cell::sync::Lazy;
-use regex::Regex;
-use std::{
-    convert::{TryFrom, TryInto},
-    error::Error,
-    ffi::OsStr,
-    fmt::{Display, Formatter, Result as FmtResult},
-    net::IpAddr,
-    str::FromStr,
-};
-
-/// Represents an email address with a user and a domain name.
-///
-/// This type contains email in canonical form (_user@domain.tld_).
-///
-/// **NOTE**: Enable feature "serde" to be able serialize/deserialize it using [serde](https://serde.rs/).
-///
-/// # Examples
-///
-/// You can create an `Address` from a user and a domain:
-///
-/// ```
-/// use lettre::Address;
-///
-/// # use std::error::Error;
-/// # fn main() -> Result<(), Box<dyn Error>> {
-/// let address = Address::new("user", "email.com")?;
-/// assert_eq!(address.user(), "user");
-/// assert_eq!(address.domain(), "email.com");
-/// # Ok(())
-/// # }
-/// ```
-///
-/// You can also create an `Address` from a string literal by parsing it:
-///
-/// ```
-/// use lettre::Address;
-///
-/// # use std::error::Error;
-/// # fn main() -> Result<(), Box<dyn Error>> {
-/// let address = "user@email.com".parse::<Address>()?;
-/// assert_eq!(address.user(), "user");
-/// assert_eq!(address.domain(), "email.com");
-/// # Ok(())
-/// # }
-/// ```
-#[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
-pub struct Address {
-    /// Complete address
-    serialized: String,
-    /// Index into `serialized` before the '@'
-    at_start: usize,
-}
-
-// Regex from the specs
-// https://html.spec.whatwg.org/multipage/forms.html#valid-e-mail-address
-// It will mark esoteric email addresses like quoted string as invalid
-static USER_RE: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r"^(?i)[a-z0-9.!#$%&'*+/=?^_`{|}~-]+\z").unwrap());
-static DOMAIN_RE: Lazy<Regex> = Lazy::new(|| {
-    Regex::new(
-        r"(?i)^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$",
-    )
-    .unwrap()
-});
-// literal form, ipv4 or ipv6 address (SMTP 4.1.3)
-static LITERAL_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"(?i)\[([A-f0-9:\.]+)\]\z").unwrap());
-
-impl Address {
-    /// Creates a new email address from a user and domain.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lettre::Address;
-    ///
-    /// # use std::error::Error;
-    /// # fn main() -> Result<(), Box<dyn Error>> {
-    /// let address = Address::new("user", "email.com")?;
-    /// let expected = "user@email.com".parse::<Address>()?;
-    /// assert_eq!(expected, address);
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn new<U: AsRef<str>, D: AsRef<str>>(user: U, domain: D) -> Result<Self, AddressError> {
-        (user, domain).try_into()
-    }
-
-    /// Gets the user portion of the `Address`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lettre::Address;
-    ///
-    /// # use std::error::Error;
-    /// # fn main() -> Result<(), Box<dyn Error>> {
-    /// let address = Address::new("user", "email.com")?;
-    /// assert_eq!(address.user(), "user");
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn user(&self) -> &str {
-        &self.serialized[..self.at_start]
-    }
-
-    /// Gets the domain portion of the `Address`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lettre::Address;
-    ///
-    /// # use std::error::Error;
-    /// # fn main() -> Result<(), Box<dyn Error>> {
-    /// let address = Address::new("user", "email.com")?;
-    /// assert_eq!(address.domain(), "email.com");
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn domain(&self) -> &str {
-        &self.serialized[self.at_start + 1..]
-    }
-
-    pub(super) fn check_user(user: &str) -> Result<(), AddressError> {
-        if USER_RE.is_match(user) {
-            Ok(())
-        } else {
-            Err(AddressError::InvalidUser)
-        }
-    }
-
-    pub(super) fn check_domain(domain: &str) -> Result<(), AddressError> {
-        Address::check_domain_ascii(domain).or_else(|_| {
-            domain_to_ascii(domain)
-                .map_err(|_| AddressError::InvalidDomain)
-                .and_then(|domain| Address::check_domain_ascii(&domain))
-        })
-    }
-
-    fn check_domain_ascii(domain: &str) -> Result<(), AddressError> {
-        if DOMAIN_RE.is_match(domain) {
-            return Ok(());
-        }
-
-        if let Some(caps) = LITERAL_RE.captures(domain) {
-            if let Some(cap) = caps.get(1) {
-                if cap.as_str().parse::<IpAddr>().is_ok() {
-                    return Ok(());
-                }
-            }
-        }
-
-        Err(AddressError::InvalidDomain)
-    }
-
-    #[cfg(feature = "smtp-transport")]
-    /// Check if the address contains non-ascii chars
-    pub(super) fn is_ascii(&self) -> bool {
-        self.serialized.is_ascii()
-    }
-}
-
-impl Display for Address {
-    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
-        f.write_str(&self.serialized)
-    }
-}
-
-impl FromStr for Address {
-    type Err = AddressError;
-
-    fn from_str(val: &str) -> Result<Self, AddressError> {
-        let mut parts = val.rsplitn(2, '@');
-        let domain = parts.next().ok_or(AddressError::MissingParts)?;
-        let user = parts.next().ok_or(AddressError::MissingParts)?;
-
-        Address::check_user(user)?;
-        Address::check_domain(domain)?;
-        Ok(Address {
-            serialized: val.into(),
-            at_start: user.len(),
-        })
-    }
-}
-
-impl<U, D> TryFrom<(U, D)> for Address
-where
-    U: AsRef<str>,
-    D: AsRef<str>,
-{
-    type Error = AddressError;
-
-    fn try_from((user, domain): (U, D)) -> Result<Self, Self::Error> {
-        let user = user.as_ref();
-        Address::check_user(user)?;
-
-        let domain = domain.as_ref();
-        Address::check_domain(domain)?;
-
-        let serialized = format!("{}@{}", user, domain);
-        Ok(Address {
-            serialized,
-            at_start: user.len(),
-        })
-    }
-}
-
-impl AsRef<str> for Address {
-    fn as_ref(&self) -> &str {
-        &self.serialized
-    }
-}
-
-impl AsRef<OsStr> for Address {
-    fn as_ref(&self) -> &OsStr {
-        self.serialized.as_ref()
-    }
-}
-
-#[derive(Debug, PartialEq, Clone, Copy)]
-/// Errors in email addresses parsing
-pub enum AddressError {
-    /// Missing domain or user
-    MissingParts,
-    /// Unbalanced angle bracket
-    Unbalanced,
-    /// Invalid email user
-    InvalidUser,
-    /// Invalid email domain
-    InvalidDomain,
-}
-
-impl Error for AddressError {}
-
-impl Display for AddressError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
-        match self {
-            AddressError::MissingParts => f.write_str("Missing domain or user"),
-            AddressError::Unbalanced => f.write_str("Unbalanced angle bracket"),
-            AddressError::InvalidUser => f.write_str("Invalid email user"),
-            AddressError::InvalidDomain => f.write_str("Invalid email domain"),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn parse_address() {
-        let addr_str = "something@example.com";
-        let addr = Address::from_str(addr_str).unwrap();
-        let addr2 = Address::new("something", "example.com").unwrap();
-        assert_eq!(addr, addr2);
-        assert_eq!(addr.user(), "something");
-        assert_eq!(addr.domain(), "example.com");
-        assert_eq!(addr2.user(), "something");
-        assert_eq!(addr2.domain(), "example.com");
-    }
-}

src/error.rs

@@ -1,54 +0,0 @@
-//! Error type for email messages
-
-use std::{
-    error::Error as StdError,
-    fmt::{self, Display, Formatter},
-};
-
-// FIXME message-specific errors
-/// Error type for email content
-#[derive(Debug)]
-pub enum Error {
-    /// Missing from in envelope
-    MissingFrom,
-    /// Missing to in envelope
-    MissingTo,
-    /// Can only be one from in envelope
-    TooManyFrom,
-    /// Invalid email: missing at
-    EmailMissingAt,
-    /// Invalid email: missing local part
-    EmailMissingLocalPart,
-    /// Invalid email: missing domain
-    EmailMissingDomain,
-    /// Cannot parse filename for attachment
-    CannotParseFilename,
-    /// IO error
-    Io(std::io::Error),
-    /// Non-ASCII chars
-    NonAsciiChars,
-}
-
-impl Display for Error {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), fmt::Error> {
-        match self {
-            Error::MissingFrom => f.write_str("missing source address, invalid envelope"),
-            Error::MissingTo => f.write_str("missing destination address, invalid envelope"),
-            Error::TooManyFrom => f.write_str("there can only be one source address"),
-            Error::EmailMissingAt => f.write_str("missing @ in email address"),
-            Error::EmailMissingLocalPart => f.write_str("missing local part in email address"),
-            Error::EmailMissingDomain => f.write_str("missing domain in email address"),
-            Error::CannotParseFilename => f.write_str("could not parse attachment filename"),
-            Error::NonAsciiChars => f.write_str("contains non-ASCII chars"),
-            Error::Io(e) => e.fmt(f),
-        }
-    }
-}
-
-impl From<std::io::Error> for Error {
-    fn from(err: std::io::Error) -> Error {
-        Error::Io(err)
-    }
-}
-
-impl StdError for Error {}

src/executor.rs

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

src/lib.rs

@@ -1,226 +0,0 @@
-//! Lettre is an email library that allows creating and sending messages. It provides:
-//!
-//! * An easy to use email builder
-//! * Pluggable email transports
-//! * Unicode support
-//! * Secure defaults
-//! * Async support
-//!
-//! Lettre requires Rust 1.46 or newer.
-//!
-//! ## Features
-//!
-//! This section lists each lettre feature and briefly explains it.
-//! More info about each module can be found in the corresponding module page.
-//!
-//! Features with `📫` near them are enabled by default.
-//!
-//! ### Typed message builder
-//!
-//! _Strongly typed [`message`] builder_
-//!
-//! * **builder** 📫: Enable the [`Message`] builder
-//! * **hostname** 📫: Try to use the actual system hostname in the `Message-ID` header
-//!
-//! ### SMTP transport
-//!
-//! _Send emails using [`SMTP`]_
-//!
-//! * **smtp-transport** 📫: Enable the SMTP transport
-//! * **r2d2** 📫: Connection pool for SMTP transport
-//! * **hostname** 📫: Try to use the actual system hostname for the SMTP `CLIENTID`
-//!
-//! #### SMTP over TLS via the native-tls crate
-//!
-//! _Secure SMTP connections using TLS from the `native-tls` crate_
-//!
-//! Uses schannel on Windows, Security-Framework on macOS, and OpenSSL on Linux.
-//!
-//! * **native-tls** 📫: TLS support for the synchronous version of the API
-//! * **tokio1-native-tls**: TLS support for the `tokio1` async version of the API
-//!
-//! NOTE: native-tls isn't supported with `async-std`
-//!
-//! #### SMTP over TLS via the rustls crate
-//!
-//! _Secure SMTP connections using TLS from the `rustls-tls` crate_
-//!
-//! Rustls uses [ring] as the cryptography implementation. As a result, [not all Rust's targets are supported][ring-support].
-//!
-//! * **rustls-tls**: TLS support for the synchronous version of the API
-//! * **tokio1-rustls-tls**: TLS support for the `tokio1` async version of the API
-//! * **async-std1-rustls-tls**: TLS support for the `async-std1` async version of the API
-//!
-//! ### Sendmail transport
-//!
-//! _Send emails using the [`sendmail`] command_
-//!
-//! * **sendmail-transport**: Enable the `sendmail` transport
-//!
-//! ### File transport
-//!
-//! _Save emails as an `.eml` [`file`]_
-//!
-//! * **file-transport**: Enable the file transport (saves emails into an `.eml` file)
-//! * **file-transport-envelope**: Allow writing the envelope into a JSON file (additionally saves envelopes into a `.json` file)
-//!
-//! ### Async execution runtimes
-//!
-//! _Use [tokio] or [async-std] as an async execution runtime for sending emails_
-//!
-//! The correct runtime version must be chosen in order for lettre to work correctly.
-//! For example, when sending emails from a Tokio 1.x context, the Tokio 1.x executor
-//! ([`Tokio1Executor`]) must be used. Using a different version (for example Tokio 0.2.x),
-//! or async-std, would result in a runtime panic.
-//!
-//! * **tokio1**: Allow to asynchronously send emails using [Tokio 1.x]
-//! * **async-std1**: Allow to asynchronously send emails using [async-std 1.x]
-//!
-//! NOTE: native-tls isn't supported with `async-std`
-//!
-//! ### Misc features
-//!
-//! _Additional features_
-//!
-//! * **serde**: Serialization/Deserialization of entities
-//! * **tracing**: Logging using the `tracing` crate
-//!
-//! [`SMTP`]: crate::transport::smtp
-//! [`sendmail`]: crate::transport::sendmail
-//! [`file`]: crate::transport::file
-//! [tokio]: https://docs.rs/tokio/1
-//! [async-std]: https://docs.rs/async-std/1
-//! [ring]: https://github.com/briansmith/ring#ring
-//! [ring-support]: https://github.com/briansmith/ring#online-automated-testing
-//! [Tokio 1.x]: https://docs.rs/tokio/1
-//! [async-std 1.x]: https://docs.rs/async-std/1
-
-#![doc(html_root_url = "https://docs.rs/crate/lettre/0.10.0-rc.1")]
-#![doc(html_favicon_url = "https://lettre.rs/favicon.ico")]
-#![doc(html_logo_url = "https://avatars0.githubusercontent.com/u/15113230?v=4")]
-#![forbid(unsafe_code)]
-#![deny(
-    missing_copy_implementations,
-    trivial_casts,
-    trivial_numeric_casts,
-    unstable_features,
-    unused_import_braces,
-    rust_2018_idioms
-)]
-#![cfg_attr(docsrs, feature(doc_cfg))]
-
-pub mod address;
-pub mod error;
-#[cfg(any(feature = "tokio1", feature = "async-std1"))]
-mod executor;
-#[cfg(feature = "builder")]
-#[cfg_attr(docsrs, doc(cfg(feature = "builder")))]
-pub mod message;
-pub mod transport;
-
-#[cfg(feature = "async-std1")]
-pub use self::executor::AsyncStd1Executor;
-#[cfg(all(any(feature = "tokio1", feature = "async-std1")))]
-pub use self::executor::Executor;
-#[cfg(feature = "tokio1")]
-pub use self::executor::Tokio1Executor;
-#[cfg(all(any(feature = "tokio1", feature = "async-std1")))]
-#[doc(inline)]
-pub use self::transport::AsyncTransport;
-pub use crate::address::Address;
-#[cfg(feature = "builder")]
-#[doc(inline)]
-pub use crate::message::Message;
-#[cfg(all(
-    feature = "file-transport",
-    any(feature = "tokio1", feature = "async-std1")
-))]
-#[doc(inline)]
-pub use crate::transport::file::AsyncFileTransport;
-#[cfg(feature = "file-transport")]
-#[doc(inline)]
-pub use crate::transport::file::FileTransport;
-#[cfg(all(
-    feature = "sendmail-transport",
-    any(feature = "tokio1", feature = "async-std1")
-))]
-#[doc(inline)]
-pub use crate::transport::sendmail::AsyncSendmailTransport;
-#[cfg(feature = "sendmail-transport")]
-#[doc(inline)]
-pub use crate::transport::sendmail::SendmailTransport;
-#[cfg(all(
-    feature = "smtp-transport",
-    any(feature = "tokio1", feature = "async-std1")
-))]
-pub use crate::transport::smtp::AsyncSmtpTransport;
-#[doc(inline)]
-pub use crate::transport::Transport;
-use crate::{address::Envelope, error::Error};
-
-#[cfg(feature = "smtp-transport")]
-pub use crate::transport::smtp::SmtpTransport;
-use std::error::Error as StdError;
-
-pub(crate) type BoxError = Box<dyn StdError + Send + Sync>;
-
-#[cfg(test)]
-#[cfg(feature = "builder")]
-mod test {
-    use std::convert::TryFrom;
-
-    use super::*;
-    use crate::message::{header, header::Headers, Mailbox, Mailboxes};
-
-    #[test]
-    fn envelope_from_headers() {
-        let from = Mailboxes::new().with("kayo@example.com".parse().unwrap());
-        let to = Mailboxes::new().with("amousset@example.com".parse().unwrap());
-
-        let mut headers = Headers::new();
-        headers.set(header::From(from));
-        headers.set(header::To(to));
-
-        assert_eq!(
-            Envelope::try_from(&headers).unwrap(),
-            Envelope::new(
-                Some(Address::new("kayo", "example.com").unwrap()),
-                vec![Address::new("amousset", "example.com").unwrap()]
-            )
-            .unwrap()
-        );
-    }
-
-    #[test]
-    fn envelope_from_headers_sender() {
-        let from = Mailboxes::new().with("kayo@example.com".parse().unwrap());
-        let sender = Mailbox::new(None, "kayo2@example.com".parse().unwrap());
-        let to = Mailboxes::new().with("amousset@example.com".parse().unwrap());
-
-        let mut headers = Headers::new();
-        headers.set(header::From::from(from));
-        headers.set(header::Sender::from(sender));
-        headers.set(header::To::from(to));
-
-        assert_eq!(
-            Envelope::try_from(&headers).unwrap(),
-            Envelope::new(
-                Some(Address::new("kayo2", "example.com").unwrap()),
-                vec![Address::new("amousset", "example.com").unwrap()]
-            )
-            .unwrap()
-        );
-    }
-
-    #[test]
-    fn envelope_from_headers_no_to() {
-        let from = Mailboxes::new().with("kayo@example.com".parse().unwrap());
-        let sender = Mailbox::new(None, "kayo2@example.com".parse().unwrap());
-
-        let mut headers = Headers::new();
-        headers.set(header::From::from(from));
-        headers.set(header::Sender::from(sender));
-
-        assert!(Envelope::try_from(&headers).is_err(),);
-    }
-}

src/message/attachment.rs

@@ -1,91 +0,0 @@
-use crate::message::{
-    header::{self, ContentType},
-    IntoBody, SinglePart,
-};
-
-/// `SinglePart` builder for attachments
-///
-/// Allows building attachment parts easily.
-#[derive(Clone)]
-pub struct Attachment {
-    disposition: Disposition,
-}
-
-#[derive(Clone)]
-enum Disposition {
-    /// file name
-    Attached(String),
-    /// content id
-    Inline(String),
-}
-
-impl Attachment {
-    /// Creates a new attachment
-    pub fn new(filename: String) -> Self {
-        Attachment {
-            disposition: Disposition::Attached(filename),
-        }
-    }
-
-    /// Creates a new inline attachment
-    pub fn new_inline(content_id: String) -> Self {
-        Attachment {
-            disposition: Disposition::Inline(content_id),
-        }
-    }
-
-    /// Build the attachment part
-    pub fn body<T: IntoBody>(self, content: T, content_type: ContentType) -> SinglePart {
-        let mut builder = SinglePart::builder();
-        builder = match self.disposition {
-            Disposition::Attached(filename) => {
-                builder.header(header::ContentDisposition::attachment(&filename))
-            }
-            Disposition::Inline(content_id) => builder
-                .header(header::ContentId::from(format!("<{}>", content_id)))
-                .header(header::ContentDisposition::inline()),
-        };
-        builder = builder.header(content_type);
-        builder.body(content)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::message::header::ContentType;
-
-    #[test]
-    fn attachment() {
-        let part = super::Attachment::new(String::from("test.txt")).body(
-            String::from("Hello world!"),
-            ContentType::parse("text/plain").unwrap(),
-        );
-        assert_eq!(
-            &String::from_utf8_lossy(&part.formatted()),
-            concat!(
-                "Content-Disposition: attachment; filename=\"test.txt\"\r\n",
-                "Content-Type: text/plain\r\n",
-                "Content-Transfer-Encoding: 7bit\r\n\r\n",
-                "Hello world!\r\n",
-            )
-        );
-    }
-
-    #[test]
-    fn attachment_inline() {
-        let part = super::Attachment::new_inline(String::from("id")).body(
-            String::from("Hello world!"),
-            ContentType::parse("text/plain").unwrap(),
-        );
-        assert_eq!(
-            &String::from_utf8_lossy(&part.formatted()),
-            concat!(
-                "Content-ID: <id>\r\n",
-                "Content-Disposition: inline\r\n",
-                "Content-Type: text/plain\r\n",
-                "Content-Transfer-Encoding: 7bit\r\n\r\n",
-                "Hello world!\r\n"
-            )
-        );
-    }
-}

src/message/body.rs

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

src/message/header/content.rs

@@ -1,116 +0,0 @@
-use std::{
-    fmt::{Display, Formatter as FmtFormatter, Result as FmtResult},
-    str::FromStr,
-};
-
-use super::{Header, HeaderName};
-use crate::BoxError;
-
-/// `Content-Transfer-Encoding` of the body
-///
-/// The `Message` builder takes care of choosing the most
-/// efficient encoding based on the chosen body, so in most
-/// use-caches this header shouldn't be set manually.
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum ContentTransferEncoding {
-    /// ASCII
-    SevenBit,
-    /// Quoted-Printable encoding
-    QuotedPrintable,
-    /// base64 encoding
-    Base64,
-    /// Requires `8BITMIME`
-    EightBit,
-    /// Binary data
-    Binary,
-}
-
-impl Header for ContentTransferEncoding {
-    fn name() -> HeaderName {
-        HeaderName::new_from_ascii_str("Content-Transfer-Encoding")
-    }
-
-    fn parse(s: &str) -> Result<Self, BoxError> {
-        Ok(s.parse()?)
-    }
-
-    fn display(&self) -> String {
-        self.to_string()
-    }
-}
-
-impl Display for ContentTransferEncoding {
-    fn fmt(&self, f: &mut FmtFormatter<'_>) -> FmtResult {
-        f.write_str(match *self {
-            Self::SevenBit => "7bit",
-            Self::QuotedPrintable => "quoted-printable",
-            Self::Base64 => "base64",
-            Self::EightBit => "8bit",
-            Self::Binary => "binary",
-        })
-    }
-}
-
-impl FromStr for ContentTransferEncoding {
-    type Err = String;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "7bit" => Ok(Self::SevenBit),
-            "quoted-printable" => Ok(Self::QuotedPrintable),
-            "base64" => Ok(Self::Base64),
-            "8bit" => Ok(Self::EightBit),
-            "binary" => Ok(Self::Binary),
-            _ => Err(s.into()),
-        }
-    }
-}
-
-impl Default for ContentTransferEncoding {
-    fn default() -> Self {
-        ContentTransferEncoding::Base64
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::ContentTransferEncoding;
-    use crate::message::header::{HeaderName, Headers};
-
-    #[test]
-    fn format_content_transfer_encoding() {
-        let mut headers = Headers::new();
-
-        headers.set(ContentTransferEncoding::SevenBit);
-
-        assert_eq!(headers.to_string(), "Content-Transfer-Encoding: 7bit\r\n");
-
-        headers.set(ContentTransferEncoding::Base64);
-
-        assert_eq!(headers.to_string(), "Content-Transfer-Encoding: base64\r\n");
-    }
-
-    #[test]
-    fn parse_content_transfer_encoding() {
-        let mut headers = Headers::new();
-
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("Content-Transfer-Encoding"),
-            "7bit".to_string(),
-        );
-
-        assert_eq!(
-            headers.get::<ContentTransferEncoding>(),
-            Some(ContentTransferEncoding::SevenBit)
-        );
-
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("Content-Transfer-Encoding"),
-            "base64".to_string(),
-        );
-
-        assert_eq!(
-            headers.get::<ContentTransferEncoding>(),
-            Some(ContentTransferEncoding::Base64)
-        );
-    }
-}

src/message/header/content_disposition.rs

@@ -1,89 +0,0 @@
-use super::{Header, HeaderName};
-use crate::BoxError;
-
-/// `Content-Disposition` of an attachment
-///
-/// Defined in [RFC2183](https://tools.ietf.org/html/rfc2183)
-#[derive(Debug, Clone, PartialEq)]
-pub struct ContentDisposition(String);
-
-impl ContentDisposition {
-    /// An attachment which should be displayed inline into the message
-    pub fn inline() -> Self {
-        Self("inline".into())
-    }
-
-    /// An attachment which should be displayed inline into the message, but that also
-    /// species the filename in case it were to be downloaded
-    pub fn inline_with_name(file_name: &str) -> Self {
-        debug_assert!(!file_name.contains('"'), "file_name shouldn't contain '\"'");
-        Self(format!("inline; filename=\"{}\"", file_name))
-    }
-
-    /// An attachment which is separate from the body of the message, and can be downloaded separately
-    pub fn attachment(file_name: &str) -> Self {
-        debug_assert!(!file_name.contains('"'), "file_name shouldn't contain '\"'");
-        Self(format!("attachment; filename=\"{}\"", file_name))
-    }
-}
-
-impl Header for ContentDisposition {
-    fn name() -> HeaderName {
-        HeaderName::new_from_ascii_str("Content-Disposition")
-    }
-
-    fn parse(s: &str) -> Result<Self, BoxError> {
-        Ok(Self(s.into()))
-    }
-
-    fn display(&self) -> String {
-        self.0.clone()
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::ContentDisposition;
-    use crate::message::header::{HeaderName, Headers};
-
-    #[test]
-    fn format_content_disposition() {
-        let mut headers = Headers::new();
-
-        headers.set(ContentDisposition::inline());
-
-        assert_eq!(format!("{}", headers), "Content-Disposition: inline\r\n");
-
-        headers.set(ContentDisposition::attachment("something.txt"));
-
-        assert_eq!(
-            format!("{}", headers),
-            "Content-Disposition: attachment; filename=\"something.txt\"\r\n"
-        );
-    }
-
-    #[test]
-    fn parse_content_disposition() {
-        let mut headers = Headers::new();
-
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("Content-Disposition"),
-            "inline".to_string(),
-        );
-
-        assert_eq!(
-            headers.get::<ContentDisposition>(),
-            Some(ContentDisposition::inline())
-        );
-
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("Content-Disposition"),
-            "attachment; filename=\"something.txt\"".to_string(),
-        );
-
-        assert_eq!(
-            headers.get::<ContentDisposition>(),
-            Some(ContentDisposition::attachment("something.txt"))
-        );
-    }
-}

src/message/header/content_type.rs

@@ -1,123 +0,0 @@
-use std::{
-    error::Error as StdError,
-    fmt::{self, Display},
-    str::FromStr,
-};
-
-use mime::Mime;
-
-use super::{Header, HeaderName};
-use crate::BoxError;
-
-/// `Content-Type` of the body
-///
-/// Defined in [RFC2045](https://tools.ietf.org/html/rfc2045#section-5)
-#[derive(Debug, Clone, PartialEq)]
-pub struct ContentType(Mime);
-
-impl ContentType {
-    /// A `ContentType` of type `text/plain; charset=utf-8`
-    ///
-    /// Indicates that the body is in utf-8 encoded plain text.
-    pub const TEXT_PLAIN: ContentType = Self::from_mime(mime::TEXT_PLAIN_UTF_8);
-
-    /// A `ContentType` of type `text/html; charset=utf-8`
-    ///
-    /// Indicates that the body is in utf-8 encoded html.
-    pub const TEXT_HTML: ContentType = Self::from_mime(mime::TEXT_HTML_UTF_8);
-
-    /// Parse `s` into `ContentType`
-    pub fn parse(s: &str) -> Result<ContentType, ContentTypeErr> {
-        Ok(Self::from_mime(s.parse().map_err(ContentTypeErr)?))
-    }
-
-    pub(crate) const fn from_mime(mime: Mime) -> Self {
-        Self(mime)
-    }
-
-    pub(crate) fn as_ref(&self) -> &Mime {
-        &self.0
-    }
-}
-
-impl Header for ContentType {
-    fn name() -> HeaderName {
-        HeaderName::new_from_ascii_str("Content-Type")
-    }
-
-    fn parse(s: &str) -> Result<Self, BoxError> {
-        Ok(Self(s.parse()?))
-    }
-
-    fn display(&self) -> String {
-        self.0.to_string()
-    }
-}
-
-impl FromStr for ContentType {
-    type Err = ContentTypeErr;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Self::parse(s)
-    }
-}
-
-/// An error occurred while trying to [`ContentType::parse`].
-#[derive(Debug)]
-pub struct ContentTypeErr(mime::FromStrError);
-
-impl StdError for ContentTypeErr {
-    fn source(&self) -> Option<&(dyn StdError + 'static)> {
-        Some(&self.0)
-    }
-}
-
-impl Display for ContentTypeErr {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        Display::fmt(&self.0, f)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::ContentType;
-    use crate::message::header::{HeaderName, Headers};
-
-    #[test]
-    fn format_content_type() {
-        let mut headers = Headers::new();
-
-        headers.set(ContentType::TEXT_PLAIN);
-
-        assert_eq!(
-            headers.to_string(),
-            "Content-Type: text/plain; charset=utf-8\r\n"
-        );
-
-        headers.set(ContentType::TEXT_HTML);
-
-        assert_eq!(
-            headers.to_string(),
-            "Content-Type: text/html; charset=utf-8\r\n"
-        );
-    }
-
-    #[test]
-    fn parse_content_type() {
-        let mut headers = Headers::new();
-
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("Content-Type"),
-            "text/plain; charset=utf-8".to_string(),
-        );
-
-        assert_eq!(headers.get::<ContentType>(), Some(ContentType::TEXT_PLAIN));
-
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("Content-Type"),
-            "text/html; charset=utf-8".to_string(),
-        );
-
-        assert_eq!(headers.get::<ContentType>(), Some(ContentType::TEXT_HTML));
-    }
-}

src/message/header/date.rs

@@ -1,133 +0,0 @@
-use std::time::SystemTime;
-
-use httpdate::HttpDate;
-
-use super::{Header, HeaderName};
-use crate::BoxError;
-
-/// Message `Date` header
-///
-/// Defined in [RFC2822](https://tools.ietf.org/html/rfc2822#section-3.3)
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub struct Date(HttpDate);
-
-impl Date {
-    /// Build a `Date` from [`SystemTime`]
-    pub fn new(st: SystemTime) -> Self {
-        Self(st.into())
-    }
-
-    /// Get the current date
-    ///
-    /// Shortcut for `Date::new(SystemTime::now())`
-    pub fn now() -> Self {
-        Self::new(SystemTime::now())
-    }
-}
-
-impl Header for Date {
-    fn name() -> HeaderName {
-        HeaderName::new_from_ascii_str("Date")
-    }
-
-    fn parse(s: &str) -> Result<Self, BoxError> {
-        let mut s = String::from(s);
-        if s.ends_with(" -0000") {
-            // The httpdate crate expects the `Date` to end in ` GMT`, but email
-            // uses `-0000`, so we crudely fix this issue here.
-
-            s.truncate(s.len() - "-0000".len());
-            s.push_str("GMT");
-        }
-
-        Ok(Self(s.parse::<HttpDate>()?))
-    }
-
-    fn display(&self) -> String {
-        let mut s = self.0.to_string();
-        if s.ends_with(" GMT") {
-            // The httpdate crate always appends ` GMT` to the end of the string,
-            // but this is considered an obsolete date format for email
-            // https://tools.ietf.org/html/rfc2822#appendix-A.6.2,
-            // so we replace `GMT` with `-0000`
-            s.truncate(s.len() - "GMT".len());
-            s.push_str("-0000");
-        }
-
-        s
-    }
-}
-
-impl From<SystemTime> for Date {
-    fn from(st: SystemTime) -> Self {
-        Self::new(st)
-    }
-}
-
-impl From<Date> for SystemTime {
-    fn from(this: Date) -> SystemTime {
-        this.0.into()
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::time::{Duration, SystemTime};
-
-    use super::Date;
-    use crate::message::header::{HeaderName, Headers};
-
-    #[test]
-    fn format_date() {
-        let mut headers = Headers::new();
-
-        // Tue, 15 Nov 1994 08:12:31 GMT
-        headers.set(Date::from(
-            SystemTime::UNIX_EPOCH + Duration::from_secs(784887151),
-        ));
-
-        assert_eq!(
-            headers.to_string(),
-            "Date: Tue, 15 Nov 1994 08:12:31 -0000\r\n".to_string()
-        );
-
-        // Tue, 15 Nov 1994 08:12:32 GMT
-        headers.set(Date::from(
-            SystemTime::UNIX_EPOCH + Duration::from_secs(784887152),
-        ));
-
-        assert_eq!(
-            headers.to_string(),
-            "Date: Tue, 15 Nov 1994 08:12:32 -0000\r\n"
-        );
-    }
-
-    #[test]
-    fn parse_date() {
-        let mut headers = Headers::new();
-
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("Date"),
-            "Tue, 15 Nov 1994 08:12:31 -0000".to_string(),
-        );
-
-        assert_eq!(
-            headers.get::<Date>(),
-            Some(Date::from(
-                SystemTime::UNIX_EPOCH + Duration::from_secs(784887151),
-            ))
-        );
-
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("Date"),
-            "Tue, 15 Nov 1994 08:12:32 -0000".to_string(),
-        );
-
-        assert_eq!(
-            headers.get::<Date>(),
-            Some(Date::from(
-                SystemTime::UNIX_EPOCH + Duration::from_secs(784887152),
-            ))
-        );
-    }
-}

src/message/header/mailbox.rs

@@ -1,287 +0,0 @@
-use super::{Header, HeaderName};
-use crate::{
-    message::mailbox::{Mailbox, Mailboxes},
-    BoxError,
-};
-
-/// Header which can contains multiple mailboxes
-pub trait MailboxesHeader {
-    fn join_mailboxes(&mut self, other: Self);
-}
-
-macro_rules! mailbox_header {
-    ($(#[$doc:meta])*($type_name: ident, $header_name: expr)) => {
-        $(#[$doc])*
-        #[derive(Debug, Clone, PartialEq)]
-        pub struct $type_name(Mailbox);
-
-        impl Header for $type_name {
-            fn name() -> HeaderName {
-                HeaderName::new_from_ascii_str($header_name)
-            }
-
-            fn parse(s: &str) -> Result<Self, BoxError> {
-                let mailbox: Mailbox = s.parse()?;
-                Ok(Self(mailbox))
-            }
-
-            fn display(&self) -> String {
-                self.0.to_string()
-            }
-        }
-
-        impl std::convert::From<Mailbox> for $type_name {
-            #[inline]
-            fn from(mailbox: Mailbox) -> Self {
-                Self(mailbox)
-            }
-        }
-
-        impl std::convert::From<$type_name> for Mailbox {
-            #[inline]
-            fn from(this: $type_name) -> Mailbox {
-                this.0
-            }
-        }
-    };
-}
-
-macro_rules! mailboxes_header {
-    ($(#[$doc:meta])*($type_name: ident, $header_name: expr)) => {
-        $(#[$doc])*
-        #[derive(Debug, Clone, PartialEq)]
-        pub struct $type_name(pub(crate) Mailboxes);
-
-        impl MailboxesHeader for $type_name {
-            fn join_mailboxes(&mut self, other: Self) {
-                self.0.extend(other.0);
-            }
-        }
-
-        impl Header for $type_name {
-            fn name() -> HeaderName {
-                HeaderName::new_from_ascii_str($header_name)
-            }
-
-            fn parse(s: &str) -> Result<Self, BoxError> {
-                let mailbox: Mailboxes = s.parse()?;
-                Ok(Self(mailbox))
-            }
-
-            fn display(&self) -> String {
-                self.0.to_string()
-            }
-        }
-
-        impl std::convert::From<Mailboxes> for $type_name {
-            #[inline]
-            fn from(mailboxes: Mailboxes) -> Self {
-                Self(mailboxes)
-            }
-        }
-
-        impl std::convert::From<$type_name> for Mailboxes {
-            #[inline]
-            fn from(this: $type_name) -> Mailboxes {
-                this.0
-            }
-        }
-    };
-}
-
-mailbox_header! {
-    /**
-
-    `Sender` header
-
-    This header contains [`Mailbox`][self::Mailbox] associated with sender.
-
-    ```no_test
-    header::Sender("Mr. Sender <sender@example.com>".parse().unwrap())
-    ```
-     */
-    (Sender, "Sender")
-}
-
-mailboxes_header! {
-    /**
-
-    `From` header
-
-    This header contains [`Mailboxes`][self::Mailboxes].
-
-     */
-    (From, "From")
-}
-
-mailboxes_header! {
-    /**
-
-    `Reply-To` header
-
-    This header contains [`Mailboxes`][self::Mailboxes].
-
-     */
-    (ReplyTo, "Reply-To")
-}
-
-mailboxes_header! {
-    /**
-
-    `To` header
-
-    This header contains [`Mailboxes`][self::Mailboxes].
-
-     */
-    (To, "To")
-}
-
-mailboxes_header! {
-    /**
-
-    `Cc` header
-
-    This header contains [`Mailboxes`][self::Mailboxes].
-
-     */
-    (Cc, "Cc")
-}
-
-mailboxes_header! {
-    /**
-
-    `Bcc` header
-
-    This header contains [`Mailboxes`][self::Mailboxes].
-
-     */
-    (Bcc, "Bcc")
-}
-
-#[cfg(test)]
-mod test {
-    use super::{From, Mailbox, Mailboxes};
-    use crate::message::header::{HeaderName, Headers};
-
-    #[test]
-    fn format_single_without_name() {
-        let from = Mailboxes::new().with("kayo@example.com".parse().unwrap());
-
-        let mut headers = Headers::new();
-        headers.set(From(from));
-
-        assert_eq!(headers.to_string(), "From: kayo@example.com\r\n");
-    }
-
-    #[test]
-    fn format_single_with_name() {
-        let from = Mailboxes::new().with("K. <kayo@example.com>".parse().unwrap());
-
-        let mut headers = Headers::new();
-        headers.set(From(from));
-
-        assert_eq!(headers.to_string(), "From: K. <kayo@example.com>\r\n");
-    }
-
-    #[test]
-    fn format_multi_without_name() {
-        let from = Mailboxes::new()
-            .with("kayo@example.com".parse().unwrap())
-            .with("pony@domain.tld".parse().unwrap());
-
-        let mut headers = Headers::new();
-        headers.set(From(from));
-
-        assert_eq!(
-            headers.to_string(),
-            "From: kayo@example.com, pony@domain.tld\r\n"
-        );
-    }
-
-    #[test]
-    fn format_multi_with_name() {
-        let from = vec![
-            "K. <kayo@example.com>".parse().unwrap(),
-            "Pony P. <pony@domain.tld>".parse().unwrap(),
-        ];
-
-        let mut headers = Headers::new();
-        headers.set(From(from.into()));
-
-        assert_eq!(
-            headers.to_string(),
-            "From: K. <kayo@example.com>, Pony P. <pony@domain.tld>\r\n"
-        );
-    }
-
-    #[test]
-    fn format_single_with_utf8_name() {
-        let from = vec!["Кайо <kayo@example.com>".parse().unwrap()];
-
-        let mut headers = Headers::new();
-        headers.set(From(from.into()));
-
-        assert_eq!(
-            headers.to_string(),
-            "From: =?utf-8?b?0JrQsNC50L4=?= <kayo@example.com>\r\n"
-        );
-    }
-
-    #[test]
-    fn parse_single_without_name() {
-        let from = vec!["kayo@example.com".parse().unwrap()].into();
-
-        let mut headers = Headers::new();
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("From"),
-            "kayo@example.com".to_string(),
-        );
-
-        assert_eq!(headers.get::<From>(), Some(From(from)));
-    }
-
-    #[test]
-    fn parse_single_with_name() {
-        let from = vec!["K. <kayo@example.com>".parse().unwrap()].into();
-
-        let mut headers = Headers::new();
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("From"),
-            "K. <kayo@example.com>".to_string(),
-        );
-
-        assert_eq!(headers.get::<From>(), Some(From(from)));
-    }
-
-    #[test]
-    fn parse_multi_without_name() {
-        let from: Vec<Mailbox> = vec![
-            "kayo@example.com".parse().unwrap(),
-            "pony@domain.tld".parse().unwrap(),
-        ];
-
-        let mut headers = Headers::new();
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("From"),
-            "kayo@example.com, pony@domain.tld".to_string(),
-        );
-
-        assert_eq!(headers.get::<From>(), Some(From(from.into())));
-    }
-
-    #[test]
-    fn parse_multi_with_name() {
-        let from: Vec<Mailbox> = vec![
-            "K. <kayo@example.com>".parse().unwrap(),
-            "Pony P. <pony@domain.tld>".parse().unwrap(),
-        ];
-
-        let mut headers = Headers::new();
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("From"),
-            "K. <kayo@example.com>, Pony P. <pony@domain.tld>".to_string(),
-        );
-
-        assert_eq!(headers.get::<From>(), Some(From(from.into())));
-    }
-}

src/message/header/mod.rs

@@ -1,800 +0,0 @@
-//! Headers widely used in email messages
-
-use std::{
-    borrow::Cow,
-    error::Error,
-    fmt::{self, Display, Formatter},
-    ops::Deref,
-};
-
-pub use self::{
-    content::*,
-    content_disposition::ContentDisposition,
-    content_type::{ContentType, ContentTypeErr},
-    date::Date,
-    mailbox::*,
-    special::*,
-    textual::*,
-};
-use crate::BoxError;
-
-mod content;
-mod content_disposition;
-mod content_type;
-mod date;
-mod mailbox;
-mod special;
-mod textual;
-
-pub trait Header: Clone {
-    fn name() -> HeaderName;
-
-    fn parse(s: &str) -> Result<Self, BoxError>;
-
-    fn display(&self) -> String;
-}
-
-/// A set of email headers
-#[derive(Debug, Clone, Default)]
-pub struct Headers {
-    headers: Vec<(HeaderName, String)>,
-}
-
-impl Headers {
-    /// Create an empty `Headers`
-    ///
-    /// This function does not allocate.
-    #[inline]
-    pub const fn new() -> Self {
-        Self {
-            headers: Vec::new(),
-        }
-    }
-
-    /// Create an empty `Headers` with a pre-allocated capacity
-    ///
-    /// Pre-allocates a capacity of at least `capacity`.
-    #[inline]
-    pub fn with_capacity(capacity: usize) -> Self {
-        Self {
-            headers: Vec::with_capacity(capacity),
-        }
-    }
-
-    /// Returns a copy of an `Header` present in `Headers`
-    ///
-    /// Returns `None` if `Header` isn't present in `Headers`.
-    pub fn get<H: Header>(&self) -> Option<H> {
-        self.get_raw(&H::name()).and_then(|raw| H::parse(raw).ok())
-    }
-
-    /// Sets `Header` into `Headers`, overriding `Header` if it
-    /// was already present in `Headers`
-    pub fn set<H: Header>(&mut self, header: H) {
-        self.insert_raw(H::name(), header.display());
-    }
-
-    /// Remove `Header` from `Headers`, returning it
-    ///
-    /// Returns `None` if `Header` isn't in `Headers`.
-    pub fn remove<H: Header>(&mut self) -> Option<H> {
-        self.remove_raw(&H::name())
-            .and_then(|(_name, raw)| H::parse(&raw).ok())
-    }
-
-    /// Clears `Headers`, removing all headers from it
-    ///
-    /// Any pre-allocated capacity is left untouched.
-    #[inline]
-    pub fn clear(&mut self) {
-        self.headers.clear();
-    }
-
-    /// Returns a reference to the raw value of header `name`
-    ///
-    /// Returns `None` if `name` isn't present in `Headers`.
-    pub fn get_raw(&self, name: &str) -> Option<&str> {
-        self.find_header(name).map(|(_name, value)| value)
-    }
-
-    /// Inserts a raw header into `Headers`, overriding `value` if it
-    /// was already present in `Headers`.
-    pub fn insert_raw(&mut self, name: HeaderName, value: String) {
-        match self.find_header_mut(&name) {
-            Some((_, current_value)) => {
-                *current_value = value;
-            }
-            None => {
-                self.headers.push((name, value));
-            }
-        }
-    }
-
-    /// Appends a raw header into `Headers`
-    ///
-    /// If a header with a name of `name` is already present,
-    /// appends `, ` + `value` to it's current value.
-    pub fn append_raw(&mut self, name: HeaderName, value: String) {
-        match self.find_header_mut(&name) {
-            Some((_name, prev_value)) => {
-                prev_value.push_str(", ");
-                prev_value.push_str(&value);
-            }
-            None => self.headers.push((name, value)),
-        }
-    }
-
-    /// Remove a raw header from `Headers`, returning it
-    ///
-    /// Returns `None` if `name` isn't present in `Headers`.
-    pub fn remove_raw(&mut self, name: &str) -> Option<(HeaderName, String)> {
-        self.find_header_index(name).map(|i| self.headers.remove(i))
-    }
-
-    fn find_header(&self, name: &str) -> Option<(&HeaderName, &str)> {
-        self.headers
-            .iter()
-            .find(|&(name_, _value)| name.eq_ignore_ascii_case(name_))
-            .map(|t| (&t.0, t.1.as_str()))
-    }
-
-    fn find_header_mut(&mut self, name: &str) -> Option<(&HeaderName, &mut String)> {
-        self.headers
-            .iter_mut()
-            .find(|(name_, _value)| name.eq_ignore_ascii_case(name_))
-            .map(|t| (&t.0, &mut t.1))
-    }
-
-    fn find_header_index(&self, name: &str) -> Option<usize> {
-        self.headers
-            .iter()
-            .enumerate()
-            .find(|&(_i, (name_, _value))| name.eq_ignore_ascii_case(name_))
-            .map(|(i, _)| i)
-    }
-}
-
-impl Display for Headers {
-    /// Formats `Headers`, ready to put them into an email
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        for (name, value) in &self.headers {
-            Display::fmt(name, f)?;
-            f.write_str(": ")?;
-            HeaderValueEncoder::encode(&name, &value, f)?;
-            f.write_str("\r\n")?;
-        }
-
-        Ok(())
-    }
-}
-
-/// A possible error when converting a `HeaderName` from another type.
-// comes from `http` crate
-#[allow(missing_copy_implementations)]
-#[derive(Clone)]
-pub struct InvalidHeaderName {
-    _priv: (),
-}
-
-impl fmt::Debug for InvalidHeaderName {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("InvalidHeaderName")
-            // skip _priv noise
-            .finish()
-    }
-}
-
-impl fmt::Display for InvalidHeaderName {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("invalid header name")
-    }
-}
-
-impl Error for InvalidHeaderName {}
-
-/// A valid header name
-#[derive(Debug, Clone)]
-pub struct HeaderName(Cow<'static, str>);
-
-impl HeaderName {
-    /// Creates a new header name
-    pub fn new_from_ascii(ascii: String) -> Result<Self, InvalidHeaderName> {
-        if !ascii.is_empty()
-            && ascii.len() <= 76
-            && ascii.is_ascii()
-            && !ascii.contains(|c| c == ':' || c == ' ')
-        {
-            Ok(Self(Cow::Owned(ascii)))
-        } else {
-            Err(InvalidHeaderName { _priv: () })
-        }
-    }
-
-    /// Creates a new header name, panics on invalid name
-    pub const fn new_from_ascii_str(ascii: &'static str) -> Self {
-        macro_rules! static_assert {
-            ($condition:expr) => {
-                let _ = [()][(!($condition)) as usize];
-            };
-        }
-
-        static_assert!(!ascii.is_empty());
-        static_assert!(ascii.len() <= 76);
-
-        let bytes = ascii.as_bytes();
-        let mut i = 0;
-        while i < bytes.len() {
-            static_assert!(bytes[i].is_ascii());
-            static_assert!(bytes[i] != b' ');
-            static_assert!(bytes[i] != b':');
-
-            i += 1;
-        }
-
-        Self(Cow::Borrowed(ascii))
-    }
-}
-
-impl Display for HeaderName {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.write_str(&self)
-    }
-}
-
-impl Deref for HeaderName {
-    type Target = str;
-
-    #[inline]
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl AsRef<[u8]> for HeaderName {
-    #[inline]
-    fn as_ref(&self) -> &[u8] {
-        let s: &str = self.as_ref();
-        s.as_bytes()
-    }
-}
-
-impl AsRef<str> for HeaderName {
-    #[inline]
-    fn as_ref(&self) -> &str {
-        &self.0
-    }
-}
-
-impl PartialEq<HeaderName> for HeaderName {
-    fn eq(&self, other: &HeaderName) -> bool {
-        let s1: &str = self.as_ref();
-        let s2: &str = other.as_ref();
-        s1 == s2
-    }
-}
-
-impl PartialEq<&str> for HeaderName {
-    fn eq(&self, other: &&str) -> bool {
-        let s: &str = self.as_ref();
-        s == *other
-    }
-}
-
-impl PartialEq<HeaderName> for &str {
-    fn eq(&self, other: &HeaderName) -> bool {
-        let s: &str = other.as_ref();
-        *self == s
-    }
-}
-
-const ENCODING_START_PREFIX: &str = "=?utf-8?b?";
-const ENCODING_END_SUFFIX: &str = "?=";
-const MAX_LINE_LEN: usize = 76;
-
-/// [RFC 1522](https://tools.ietf.org/html/rfc1522) header value encoder
-struct HeaderValueEncoder {
-    line_len: usize,
-    encode_buf: String,
-}
-
-impl HeaderValueEncoder {
-    fn encode(name: &str, value: &str, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let (words_iter, encoder) = Self::new(name, value);
-        encoder.format(words_iter, f)
-    }
-
-    fn new<'a>(name: &str, value: &'a str) -> (WordsPlusFillIterator<'a>, Self) {
-        (
-            WordsPlusFillIterator { s: value },
-            Self {
-                line_len: name.len() + ": ".len(),
-                encode_buf: String::new(),
-            },
-        )
-    }
-
-    fn format(
-        mut self,
-        words_iter: WordsPlusFillIterator<'_>,
-        f: &mut fmt::Formatter<'_>,
-    ) -> fmt::Result {
-        /// Estimate if an encoded string of `len` would fix in an empty line
-        fn would_fit_new_line(len: usize) -> bool {
-            len < (MAX_LINE_LEN - " ".len())
-        }
-
-        /// Estimate how long a string of `len` would be after base64 encoding plus
-        /// adding the encoding prefix and suffix to it
-        fn base64_len(len: usize) -> usize {
-            ENCODING_START_PREFIX.len() + (len * 4 / 3 + 4) + ENCODING_END_SUFFIX.len()
-        }
-
-        /// Estimate how many more bytes we can fit in the current line
-        fn available_len_to_max_encode_len(len: usize) -> usize {
-            len.saturating_sub(
-                ENCODING_START_PREFIX.len() + (len * 3 / 4 + 4) + ENCODING_END_SUFFIX.len(),
-            )
-        }
-
-        for next_word in words_iter {
-            let allowed = allowed_str(next_word);
-
-            if allowed {
-                // This word only contains allowed characters
-
-                // the next word is allowed, but we may have accumulated some words to encode
-                self.flush_encode_buf(f, true)?;
-
-                if next_word.len() > self.remaining_line_len() {
-                    // not enough space left on this line to encode word
-
-                    if self.something_written_to_this_line() && would_fit_new_line(next_word.len())
-                    {
-                        // word doesn't fit this line, but something had already been written to it,
-                        // and word would fit the next line, so go to a new line
-                        // so go to new line
-                        self.new_line(f)?;
-                    } else {
-                        // word neither fits this line and the next one, cut it
-                        // in the middle and make it fit
-
-                        let mut next_word = next_word;
-
-                        while !next_word.is_empty() {
-                            if self.remaining_line_len() == 0 {
-                                self.new_line(f)?;
-                            }
-
-                            let len = self.remaining_line_len().min(next_word.len());
-                            let first_part = &next_word[..len];
-                            next_word = &next_word[len..];
-
-                            f.write_str(first_part)?;
-                            self.line_len += first_part.len();
-                        }
-
-                        continue;
-                    }
-                }
-
-                // word fits, write it!
-                f.write_str(next_word)?;
-                self.line_len += next_word.len();
-            } else {
-                // This word contains unallowed characters
-
-                if self.remaining_line_len() >= base64_len(self.encode_buf.len() + next_word.len())
-                {
-                    // next_word fits
-                    self.encode_buf.push_str(next_word);
-                    continue;
-                }
-
-                // next_word doesn't fit this line
-
-                if would_fit_new_line(base64_len(next_word.len())) {
-                    // ...but it would fit the next one
-
-                    self.flush_encode_buf(f, false)?;
-                    self.new_line(f)?;
-
-                    self.encode_buf.push_str(next_word);
-                    continue;
-                }
-
-                // ...and also wouldn't fit the next one.
-                // chop it up into pieces
-
-                let mut next_word = next_word;
-
-                while !next_word.is_empty() {
-                    if self.remaining_line_len() <= base64_len(1) {
-                        self.flush_encode_buf(f, false)?;
-                        self.new_line(f)?;
-                    }
-
-                    let mut len = available_len_to_max_encode_len(self.remaining_line_len())
-                        .min(next_word.len());
-                    // avoid slicing on a char boundary
-                    while !next_word.is_char_boundary(len) {
-                        len += 1;
-                    }
-                    let first_part = &next_word[..len];
-                    next_word = &next_word[len..];
-
-                    self.encode_buf.push_str(first_part);
-                }
-            }
-        }
-
-        self.flush_encode_buf(f, false)?;
-
-        Ok(())
-    }
-
-    /// Returns the number of bytes left for the current line
-    fn remaining_line_len(&self) -> usize {
-        MAX_LINE_LEN - self.line_len
-    }
-
-    /// Returns true if something has been written to the current line
-    fn something_written_to_this_line(&self) -> bool {
-        self.line_len > 1
-    }
-
-    fn flush_encode_buf(
-        &mut self,
-        f: &mut fmt::Formatter<'_>,
-        switching_to_allowed: bool,
-    ) -> fmt::Result {
-        use std::fmt::Write;
-
-        if self.encode_buf.is_empty() {
-            // nothing to encode
-            return Ok(());
-        }
-
-        let mut write_after = None;
-
-        if switching_to_allowed {
-            // If the next word only contains allowed characters, and the string to encode
-            // ends with a space, take the space out of the part to encode
-
-            let last_char = self.encode_buf.pop().expect("self.encode_buf isn't empty");
-            if is_space_like(last_char) {
-                write_after = Some(last_char);
-            } else {
-                self.encode_buf.push(last_char);
-            }
-        }
-
-        f.write_str(ENCODING_START_PREFIX)?;
-        let encoded = base64::display::Base64Display::with_config(
-            self.encode_buf.as_bytes(),
-            base64::STANDARD,
-        );
-        Display::fmt(&encoded, f)?;
-        f.write_str(ENCODING_END_SUFFIX)?;
-
-        self.line_len += ENCODING_START_PREFIX.len();
-        self.line_len += self.encode_buf.len() * 4 / 3 + 4;
-        self.line_len += ENCODING_END_SUFFIX.len();
-
-        if let Some(write_after) = write_after {
-            f.write_char(write_after)?;
-            self.line_len += 1;
-        }
-
-        self.encode_buf.clear();
-        Ok(())
-    }
-
-    fn new_line(&mut self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("\r\n ")?;
-        self.line_len = 1;
-
-        Ok(())
-    }
-}
-
-/// Iterator yielding a string split space by space, but including all space
-/// characters between it and the next word
-struct WordsPlusFillIterator<'a> {
-    s: &'a str,
-}
-
-impl<'a> Iterator for WordsPlusFillIterator<'a> {
-    type Item = &'a str;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.s.is_empty() {
-            return None;
-        }
-
-        let next_word = self
-            .s
-            .char_indices()
-            .skip(1)
-            .skip_while(|&(_i, c)| !is_space_like(c))
-            .find(|&(_i, c)| !is_space_like(c))
-            .map(|(i, _)| i);
-
-        let word = &self.s[..next_word.unwrap_or_else(|| self.s.len())];
-        self.s = &self.s[word.len()..];
-        Some(word)
-    }
-}
-
-const fn is_space_like(c: char) -> bool {
-    c == ',' || c == ' '
-}
-
-fn allowed_str(s: &str) -> bool {
-    s.chars().all(allowed_char)
-}
-
-const fn allowed_char(c: char) -> bool {
-    c >= 1 as char && c <= 9 as char
-        || c == 11 as char
-        || c == 12 as char
-        || c >= 14 as char && c <= 127 as char
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{HeaderName, Headers};
-
-    #[test]
-    fn valid_headername() {
-        assert!(HeaderName::new_from_ascii(String::from("From")).is_ok());
-    }
-
-    #[test]
-    fn non_ascii_headername() {
-        assert!(HeaderName::new_from_ascii(String::from("🌎")).is_err());
-    }
-
-    #[test]
-    fn spaces_in_headername() {
-        assert!(HeaderName::new_from_ascii(String::from("From ")).is_err());
-    }
-
-    #[test]
-    fn colons_in_headername() {
-        assert!(HeaderName::new_from_ascii(String::from("From:")).is_err());
-    }
-
-    #[test]
-    fn empty_headername() {
-        assert!(HeaderName::new_from_ascii(String::from("")).is_err());
-    }
-
-    #[test]
-    fn const_valid_headername() {
-        let _ = HeaderName::new_from_ascii_str("From");
-    }
-
-    #[test]
-    #[should_panic]
-    fn const_non_ascii_headername() {
-        let _ = HeaderName::new_from_ascii_str("🌎");
-    }
-
-    #[test]
-    #[should_panic]
-    fn const_spaces_in_headername() {
-        let _ = HeaderName::new_from_ascii_str("From ");
-    }
-
-    #[test]
-    #[should_panic]
-    fn const_colons_in_headername() {
-        let _ = HeaderName::new_from_ascii_str("From:");
-    }
-
-    #[test]
-    #[should_panic]
-    fn const_empty_headername() {
-        let _ = HeaderName::new_from_ascii_str("");
-    }
-
-    // names taken randomly from https://it.wikipedia.org/wiki/Pinco_Pallino
-
-    #[test]
-    fn format_ascii() {
-        let mut headers = Headers::new();
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("To"),
-            "John Doe <example@example.com>, Jean Dupont <jean@example.com>".to_string(),
-        );
-
-        assert_eq!(
-            headers.to_string(),
-            "To: John Doe <example@example.com>, Jean Dupont <jean@example.com>\r\n"
-        );
-    }
-
-    #[test]
-    fn format_ascii_with_folding() {
-        let mut headers = Headers::new();
-        headers.insert_raw(
-            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(),
-        );
-
-        assert_eq!(
-            headers.to_string(),
-            concat!(
-                "To: Ascii <example@example.com>, John Doe <johndoe@example.com, John Smith \r\n",
-                " <johnsmith@example.com>, Pinco Pallino <pincopallino@example.com>, Jemand \r\n",
-                " <jemand@example.com>, Jean Dupont <jean@example.com>\r\n"
-            )
-        );
-    }
-
-    #[test]
-    fn format_ascii_with_folding_long_line() {
-        let mut headers = Headers::new();
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("Subject"),
-            "Hello! This is lettre, and this IsAVeryLongLineDoYouKnowWhatsGoingToHappenIGuessWeAreGoingToFindOut. Ok I guess that's it!".to_string()
-        );
-
-        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"
-            )
-        );
-    }
-
-    #[test]
-    fn format_ascii_with_folding_very_long_line() {
-        let mut headers = Headers::new();
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("Subject"),
-            "Hello! IGuessTheLastLineWasntLongEnoughSoLetsTryAgainShallWeWhatDoYouThinkItsGoingToHappenIGuessWereAboutToFindOut! I don't know".to_string()
-        );
-
-        assert_eq!(
-            headers.to_string(),
-            concat!(
-                "Subject: Hello! IGuessTheLastLineWasntLongEnoughSoLetsTryAgainShallWeWhatDoY\r\n",
-                " ouThinkItsGoingToHappenIGuessWereAboutToFindOut! I don't know\r\n",
-            )
-        );
-    }
-
-    #[test]
-    fn format_ascii_with_folding_giant_word() {
-        let mut headers = Headers::new();
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("Subject"),
-            "1abcdefghijklmnopqrstuvwxyz2abcdefghijklmnopqrstuvwxyz3abcdefghijklmnopqrstuvwxyz4abcdefghijklmnopqrstuvwxyz5abcdefghijklmnopqrstuvwxyz6abcdefghijklmnopqrstuvwxyz".to_string()
-        );
-
-        assert_eq!(
-            headers.to_string(),
-            concat!(
-                "Subject: 1abcdefghijklmnopqrstuvwxyz2abcdefghijklmnopqrstuvwxyz3abcdefghijkl\r\n",
-                " mnopqrstuvwxyz4abcdefghijklmnopqrstuvwxyz5abcdefghijklmnopqrstuvwxyz6abcdef\r\n",
-                " ghijklmnopqrstuvwxyz\r\n",
-            )
-        );
-    }
-
-    #[test]
-    fn format_special() {
-        let mut headers = Headers::new();
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("To"),
-            "Seán <sean@example.com>".to_string(),
-        );
-
-        assert_eq!(
-            headers.to_string(),
-            "To: =?utf-8?b?U2XDoW4=?= <sean@example.com>\r\n"
-        );
-    }
-
-    #[test]
-    fn format_special_emoji() {
-        let mut headers = Headers::new();
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("To"),
-            "🌎 <world@example.com>".to_string(),
-        );
-
-        assert_eq!(
-            headers.to_string(),
-            "To: =?utf-8?b?8J+Mjg==?= <world@example.com>\r\n"
-        );
-    }
-
-    #[test]
-    fn format_special_with_folding() {
-        let mut headers = Headers::new();
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("To"),
-            "🌍 <world@example.com>, 🦆 Everywhere <ducks@example.com>, Иванов Иван Иванович <ivanov@example.com>, Jānis Bērziņš <janis@example.com>, Seán Ó Rudaí <sean@example.com>".to_string(),
-        );
-
-        assert_eq!(
-            headers.to_string(),
-            concat!(
-                "To: =?utf-8?b?8J+MjQ==?= <world@example.com>, =?utf-8?b?8J+mhg==?= \r\n",
-                " Everywhere <ducks@example.com>, =?utf-8?b?0JjQstCw0L3QvtCyIA==?=\r\n",
-                " =?utf-8?b?0JjQstCw0L0g0JjQstCw0L3QvtCy0LjRhw==?= <ivanov@example.com>, \r\n",
-                " =?utf-8?b?SsSBbmlzIELEk3J6acWGxaE=?= <janis@example.com>, \r\n",
-                " =?utf-8?b?U2XDoW4gw5MgUnVkYcOt?= <sean@example.com>\r\n"
-            )
-        );
-    }
-
-    #[test]
-    fn format_slice_on_char_boundary_bug() {
-        let mut headers = Headers::new();
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("Subject"),
-            "🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳🥳".to_string(),
-        );
-
-        assert_eq!(
-            headers.to_string(),
-            "Subject: =?utf-8?b?8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz8J+ls/CfpbPwn6Wz?=\r\n"
-        );
-    }
-
-    #[test]
-    fn format_bad_stuff() {
-        let mut headers = Headers::new();
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("Subject"),
-            "Hello! \r\n This is \" bad \0. 👋".to_string(),
-        );
-
-        assert_eq!(
-            headers.to_string(),
-            "Subject: Hello! =?utf-8?b?DQo=?= This is \" bad =?utf-8?b?AC4g8J+Riw==?=\r\n"
-        );
-    }
-
-    #[test]
-    fn format_everything() {
-        let mut headers = Headers::new();
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("Subject"),
-            "Hello! This is lettre, and this IsAVeryLongLineDoYouKnowWhatsGoingToHappenIGuessWeAreGoingToFindOut. Ok I guess that's it!".to_string()
-        );
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("To"),
-            "🌍 <world@example.com>, 🦆 Everywhere <ducks@example.com>, Иванов Иван Иванович <ivanov@example.com>, Jānis Bērziņš <janis@example.com>, Seán Ó Rudaí <sean@example.com>".to_string(),
-        );
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("From"),
-            "Someone <somewhere@example.com>".to_string(),
-        );
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("Content-Transfer-Encoding"),
-            "quoted-printable".to_string(),
-        );
-
-        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==?= \r\n",
-                " Everywhere <ducks@example.com>, =?utf-8?b?0JjQstCw0L3QvtCyIA==?=\r\n",
-                " =?utf-8?b?0JjQstCw0L0g0JjQstCw0L3QvtCy0LjRhw==?= <ivanov@example.com>, \r\n",
-                " =?utf-8?b?SsSBbmlzIELEk3J6acWGxaE=?= <janis@example.com>, \r\n",
-                " =?utf-8?b?U2XDoW4gw5MgUnVkYcOt?= <sean@example.com>\r\n",
-                "From: Someone <somewhere@example.com>\r\n",
-                "Content-Transfer-Encoding: quoted-printable\r\n",
-            )
-        );
-    }
-}

src/message/header/special.rs

@@ -1,97 +0,0 @@
-use crate::{
-    message::header::{Header, HeaderName},
-    BoxError,
-};
-
-/// Message format version, defined in [RFC2045](https://tools.ietf.org/html/rfc2045#section-4)
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub struct MimeVersion {
-    major: u8,
-    minor: u8,
-}
-
-pub const MIME_VERSION_1_0: MimeVersion = MimeVersion::new(1, 0);
-
-impl MimeVersion {
-    pub const fn new(major: u8, minor: u8) -> Self {
-        MimeVersion { major, minor }
-    }
-
-    #[inline]
-    pub const fn major(self) -> u8 {
-        self.major
-    }
-
-    #[inline]
-    pub const fn minor(self) -> u8 {
-        self.minor
-    }
-}
-
-impl Header for MimeVersion {
-    fn name() -> HeaderName {
-        HeaderName::new_from_ascii_str("MIME-Version")
-    }
-
-    fn parse(s: &str) -> Result<Self, BoxError> {
-        let mut s = s.split('.');
-
-        let major = s
-            .next()
-            .expect("The first call to next for a Split<char> always succeeds");
-        let minor = s
-            .next()
-            .ok_or_else(|| String::from("MIME-Version header doesn't contain '.'"))?;
-        let major = major.parse()?;
-        let minor = minor.parse()?;
-        Ok(MimeVersion::new(major, minor))
-    }
-
-    fn display(&self) -> String {
-        format!("{}.{}", self.major, self.minor)
-    }
-}
-
-impl Default for MimeVersion {
-    fn default() -> Self {
-        MIME_VERSION_1_0
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::{MimeVersion, MIME_VERSION_1_0};
-    use crate::message::header::{HeaderName, Headers};
-
-    #[test]
-    fn format_mime_version() {
-        let mut headers = Headers::new();
-
-        headers.set(MIME_VERSION_1_0);
-
-        assert_eq!(headers.to_string(), "MIME-Version: 1.0\r\n");
-
-        headers.set(MimeVersion::new(0, 1));
-
-        assert_eq!(headers.to_string(), "MIME-Version: 0.1\r\n");
-    }
-
-    #[test]
-    fn parse_mime_version() {
-        let mut headers = Headers::new();
-
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("MIME-Version"),
-            "1.0".to_string(),
-        );
-
-        assert_eq!(headers.get::<MimeVersion>(), Some(MIME_VERSION_1_0));
-
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("MIME-Version"),
-            "0.1".to_string(),
-        );
-
-        assert_eq!(headers.get::<MimeVersion>(), Some(MimeVersion::new(0, 1)));
-    }
-}

src/message/header/textual.rs

@@ -1,123 +0,0 @@
-use super::{Header, HeaderName};
-use crate::BoxError;
-
-macro_rules! text_header {
-    ($(#[$attr:meta])* Header($type_name: ident, $header_name: expr )) => {
-        $(#[$attr])*
-        #[derive(Debug, Clone, PartialEq)]
-        pub struct $type_name(String);
-
-        impl Header for $type_name {
-            fn name() -> HeaderName {
-                HeaderName::new_from_ascii_str($header_name)
-            }
-
-            fn parse(s: &str) -> Result<Self, BoxError> {
-                Ok(Self(s.into()))
-            }
-
-            fn display(&self) -> String {
-                self.0.clone()
-            }
-        }
-
-        impl From<String> for $type_name {
-            #[inline]
-            fn from(text: String) -> Self {
-                Self(text)
-            }
-        }
-
-        impl AsRef<str> for $type_name {
-            #[inline]
-            fn as_ref(&self) -> &str {
-                &self.0
-            }
-        }
-    };
-}
-
-text_header!(
-    /// `Subject` of the message, defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.5)
-    Header(Subject, "Subject")
-);
-text_header!(
-    /// `Comments` of the message, defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.5)
-    Header(Comments, "Comments")
-);
-text_header!(
-    /// `Keywords` header. Should contain a comma-separated list of one or more
-    /// words or quoted-strings, defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.5)
-    Header(Keywords, "Keywords")
-);
-text_header!(
-    /// `In-Reply-To` header. Contains one or more
-    /// unique message identifiers,
-    /// defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.4)
-    Header(InReplyTo, "In-Reply-To")
-);
-text_header!(
-    /// `References` header. Contains one or more
-    /// unique message identifiers,
-    /// defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.4)
-    Header(References, "References")
-);
-text_header!(
-    /// `Message-Id` header. Contains a unique message identifier,
-    /// defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.4)
-    Header(MessageId, "Message-ID")
-);
-text_header!(
-    /// `User-Agent` header. Contains information about the client,
-    /// defined in [draft-melnikov-email-user-agent-00](https://tools.ietf.org/html/draft-melnikov-email-user-agent-00#section-3)
-    Header(UserAgent, "User-Agent")
-);
-text_header! {
-    /// `Content-Id` header,
-    /// defined in [RFC2045](https://tools.ietf.org/html/rfc2045#section-7)
-    Header(ContentId, "Content-ID")
-}
-text_header! {
-    /// `Content-Location` header,
-    /// defined in [RFC2110](https://tools.ietf.org/html/rfc2110#section-4.3)
-    Header(ContentLocation, "Content-Location")
-}
-
-#[cfg(test)]
-mod test {
-    use super::Subject;
-    use crate::message::header::{HeaderName, Headers};
-
-    #[test]
-    fn format_ascii() {
-        let mut headers = Headers::new();
-        headers.set(Subject("Sample subject".into()));
-
-        assert_eq!(headers.to_string(), "Subject: Sample subject\r\n");
-    }
-
-    #[test]
-    fn format_utf8() {
-        let mut headers = Headers::new();
-        headers.set(Subject("Тема сообщения".into()));
-
-        assert_eq!(
-            headers.to_string(),
-            "Subject: =?utf-8?b?0KLQtdC80LAg0YHQvtC+0LHRidC10L3QuNGP?=\r\n"
-        );
-    }
-
-    #[test]
-    fn parse_ascii() {
-        let mut headers = Headers::new();
-        headers.insert_raw(
-            HeaderName::new_from_ascii_str("Subject"),
-            "Sample subject".to_string(),
-        );
-
-        assert_eq!(
-            headers.get::<Subject>(),
-            Some(Subject("Sample subject".into()))
-        );
-    }
-}

src/message/mailbox/mod.rs

@@ -1,5 +0,0 @@
-#[cfg(feature = "serde")]
-mod serde;
-mod types;
-
-pub use self::types::*;

src/message/mailbox/serde.rs

@@ -1,215 +0,0 @@
-use crate::message::{Mailbox, Mailboxes};
-use serde::{
-    de::{Deserializer, Error as DeError, MapAccess, SeqAccess, Visitor},
-    ser::Serializer,
-    Deserialize, Serialize,
-};
-use std::fmt::{Formatter, Result as FmtResult};
-
-impl Serialize for Mailbox {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(&self.to_string())
-    }
-}
-
-impl<'de> Deserialize<'de> for Mailbox {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        enum Field {
-            Name,
-            Email,
-        }
-
-        const FIELDS: &[&str] = &["name", "email"];
-
-        impl<'de> Deserialize<'de> for Field {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                struct FieldVisitor;
-
-                impl<'de> Visitor<'de> for FieldVisitor {
-                    type Value = Field;
-
-                    fn expecting(&self, formatter: &mut Formatter<'_>) -> FmtResult {
-                        formatter.write_str("'name' or 'email'")
-                    }
-
-                    fn visit_str<E>(self, value: &str) -> Result<Field, E>
-                    where
-                        E: DeError,
-                    {
-                        match value {
-                            "name" => Ok(Field::Name),
-                            "email" => Ok(Field::Email),
-                            _ => Err(DeError::unknown_field(value, FIELDS)),
-                        }
-                    }
-                }
-
-                deserializer.deserialize_identifier(FieldVisitor)
-            }
-        }
-
-        struct MailboxVisitor;
-
-        impl<'de> Visitor<'de> for MailboxVisitor {
-            type Value = Mailbox;
-
-            fn expecting(&self, formatter: &mut Formatter<'_>) -> FmtResult {
-                formatter.write_str("mailbox string or object")
-            }
-
-            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-            where
-                E: DeError,
-            {
-                s.parse().map_err(DeError::custom)
-            }
-
-            fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
-            where
-                V: MapAccess<'de>,
-            {
-                let mut name = None;
-                let mut addr = None;
-                while let Some(key) = map.next_key()? {
-                    match key {
-                        Field::Name => {
-                            if name.is_some() {
-                                return Err(DeError::duplicate_field("name"));
-                            }
-                            name = Some(map.next_value()?);
-                        }
-                        Field::Email => {
-                            if addr.is_some() {
-                                return Err(DeError::duplicate_field("email"));
-                            }
-                            addr = Some(map.next_value()?);
-                        }
-                    }
-                }
-                let addr = addr.ok_or_else(|| DeError::missing_field("email"))?;
-                Ok(Mailbox::new(name, addr))
-            }
-        }
-
-        deserializer.deserialize_any(MailboxVisitor)
-    }
-}
-
-impl Serialize for Mailboxes {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(&self.to_string())
-    }
-}
-
-impl<'de> Deserialize<'de> for Mailboxes {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct MailboxesVisitor;
-
-        impl<'de> Visitor<'de> for MailboxesVisitor {
-            type Value = Mailboxes;
-
-            fn expecting(&self, formatter: &mut Formatter<'_>) -> FmtResult {
-                formatter.write_str("mailboxes string or sequence")
-            }
-
-            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-            where
-                E: DeError,
-            {
-                s.parse().map_err(DeError::custom)
-            }
-
-            fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
-            where
-                V: SeqAccess<'de>,
-            {
-                let mut mboxes = Mailboxes::new();
-                while let Some(mbox) = seq.next_element()? {
-                    mboxes.push(mbox);
-                }
-                Ok(mboxes)
-            }
-        }
-
-        deserializer.deserialize_any(MailboxesVisitor)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::address::Address;
-    use serde_json::from_str;
-
-    #[test]
-    fn parse_address_string() {
-        let m: Address = from_str(r#""kayo@example.com""#).unwrap();
-        assert_eq!(m, "kayo@example.com".parse().unwrap());
-    }
-
-    #[test]
-    fn parse_address_object() {
-        let m: Address = from_str(r#"{ "user": "kayo", "domain": "example.com" }"#).unwrap();
-        assert_eq!(m, "kayo@example.com".parse().unwrap());
-    }
-
-    #[test]
-    fn parse_mailbox_string() {
-        let m: Mailbox = from_str(r#""Kai <kayo@example.com>""#).unwrap();
-        assert_eq!(m, "Kai <kayo@example.com>".parse().unwrap());
-    }
-
-    #[test]
-    fn parse_mailbox_object_address_stirng() {
-        let m: Mailbox = from_str(r#"{ "name": "Kai", "email": "kayo@example.com" }"#).unwrap();
-        assert_eq!(m, "Kai <kayo@example.com>".parse().unwrap());
-    }
-
-    #[test]
-    fn parse_mailbox_object_address_object() {
-        let m: Mailbox =
-            from_str(r#"{ "name": "Kai", "email": { "user": "kayo", "domain": "example.com" } }"#)
-                .unwrap();
-        assert_eq!(m, "Kai <kayo@example.com>".parse().unwrap());
-    }
-
-    #[test]
-    fn parse_mailboxes_string() {
-        let m: Mailboxes =
-            from_str(r#""yin@dtb.com, Hei <hei@dtb.com>, Kai <kayo@example.com>""#).unwrap();
-        assert_eq!(
-            m,
-            "<yin@dtb.com>, Hei <hei@dtb.com>, Kai <kayo@example.com>"
-                .parse()
-                .unwrap()
-        );
-    }
-
-    #[test]
-    fn parse_mailboxes_array() {
-        let m: Mailboxes =
-            from_str(r#"["yin@dtb.com", { "name": "Hei", "email": "hei@dtb.com" }, { "name": "Kai", "email": { "user": "kayo", "domain": "example.com" } }]"#)
-                .unwrap();
-        assert_eq!(
-            m,
-            "<yin@dtb.com>, Hei <hei@dtb.com>, Kai <kayo@example.com>"
-                .parse()
-                .unwrap()
-        );
-    }
-}

src/message/mailbox/types.rs

@@ -1,424 +0,0 @@
-use crate::address::{Address, AddressError};
-use std::{
-    convert::TryFrom,
-    fmt::{Display, Formatter, Result as FmtResult, Write},
-    slice::Iter,
-    str::FromStr,
-};
-
-/// Represents an email address with an optional name for the sender/recipient.
-///
-/// This type contains email address and the sender/recipient name (_Some Name \<user@domain.tld\>_ or _withoutname@domain.tld_).
-///
-/// **NOTE**: Enable feature "serde" to be able serialize/deserialize it using [serde](https://serde.rs/).
-///
-/// # Examples
-///
-/// You can create a `Mailbox` from a string and an [`Address`]:
-///
-/// ```
-/// # use lettre::{Address, message::Mailbox};
-/// # use std::error::Error;
-/// # fn main() -> Result<(), Box<dyn Error>> {
-/// let address = Address::new("example", "email.com")?;
-/// let mailbox = Mailbox::new(None, address);
-/// # Ok(())
-/// # }
-/// ```
-///
-/// You can also create one from a string literal:
-///
-/// ```
-/// # use lettre::message::Mailbox;
-/// # use std::error::Error;
-/// # fn main() -> Result<(), Box<dyn Error>> {
-/// let mailbox: Mailbox = "John Smith <example@email.com>".parse()?;
-/// # Ok(())
-/// # }
-/// ```
-#[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
-pub struct Mailbox {
-    /// The name associated with the address.
-    pub name: Option<String>,
-
-    /// The email address itself.
-    pub email: Address,
-}
-
-impl Mailbox {
-    /// Creates a new `Mailbox` using an email address and the name of the recipient if there is one.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lettre::{message::Mailbox, Address};
-    ///
-    /// # use std::error::Error;
-    /// # fn main() -> Result<(), Box<dyn Error>> {
-    /// let address = Address::new("example", "email.com")?;
-    /// let mailbox = Mailbox::new(None, address);
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn new(name: Option<String>, email: Address) -> Self {
-        Mailbox { name, email }
-    }
-}
-
-impl Display for Mailbox {
-    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
-        if let Some(ref name) = self.name {
-            let name = name.trim();
-            if !name.is_empty() {
-                f.write_str(&name)?;
-                f.write_str(" <")?;
-                self.email.fmt(f)?;
-                return f.write_char('>');
-            }
-        }
-        self.email.fmt(f)
-    }
-}
-
-impl<S: Into<String>, T: Into<String>> TryFrom<(S, T)> for Mailbox {
-    type Error = AddressError;
-
-    fn try_from(header: (S, T)) -> Result<Self, Self::Error> {
-        let (name, address) = header;
-        Ok(Mailbox::new(Some(name.into()), address.into().parse()?))
-    }
-}
-
-/*
-impl<S: AsRef<&str>, T: AsRef<&str>> TryFrom<(S, T)> for Mailbox {
-    type Error = AddressError;
-
-    fn try_from(header: (S, T)) -> Result<Self, Self::Error> {
-        let (name, address) = header;
-        Ok(Mailbox::new(Some(name.as_ref()), address.as_ref().parse()?))
-    }
-}*/
-
-impl FromStr for Mailbox {
-    type Err = AddressError;
-
-    fn from_str(src: &str) -> Result<Mailbox, Self::Err> {
-        match (src.find('<'), src.find('>')) {
-            (Some(addr_open), Some(addr_close)) if addr_open < addr_close => {
-                let name = src.split_at(addr_open).0;
-                let addr_open = addr_open + 1;
-                let addr = src.split_at(addr_open).1.split_at(addr_close - addr_open).0;
-                let addr = addr.parse()?;
-                let name = name.trim();
-                let name = if name.is_empty() {
-                    None
-                } else {
-                    Some(name.into())
-                };
-                Ok(Mailbox::new(name, addr))
-            }
-            (Some(_), _) => Err(AddressError::Unbalanced),
-            _ => {
-                let addr = src.parse()?;
-                Ok(Mailbox::new(None, addr))
-            }
-        }
-    }
-}
-
-/// Represents a sequence of [`Mailbox`] instances.
-///
-/// This type contains a sequence of mailboxes (_Some Name \<user@domain.tld\>, Another Name \<other@domain.tld\>, withoutname@domain.tld, ..._).
-///
-/// **NOTE**: Enable feature "serde" to be able serialize/deserialize it using [serde](https://serde.rs/).
-#[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
-pub struct Mailboxes(Vec<Mailbox>);
-
-impl Mailboxes {
-    /// Creates a new list of [`Mailbox`] instances.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lettre::message::Mailboxes;
-    /// let mailboxes = Mailboxes::new();
-    /// ```
-    pub fn new() -> Self {
-        Mailboxes(Vec::new())
-    }
-
-    /// Adds a new [`Mailbox`] to the list, in a builder style pattern.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lettre::{
-    ///     message::{Mailbox, Mailboxes},
-    ///     Address,
-    /// };
-    ///
-    /// # use std::error::Error;
-    /// # fn main() -> Result<(), Box<dyn Error>> {
-    /// let address = Address::new("example", "email.com")?;
-    /// let mut mailboxes = Mailboxes::new().with(Mailbox::new(None, address));
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn with(mut self, mbox: Mailbox) -> Self {
-        self.0.push(mbox);
-        self
-    }
-
-    /// Adds a new [`Mailbox`] to the list, in a Vec::push style pattern.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lettre::{
-    ///     message::{Mailbox, Mailboxes},
-    ///     Address,
-    /// };
-    ///
-    /// # use std::error::Error;
-    /// # fn main() -> Result<(), Box<dyn Error>> {
-    /// let address = Address::new("example", "email.com")?;
-    /// let mut mailboxes = Mailboxes::new();
-    /// mailboxes.push(Mailbox::new(None, address));
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn push(&mut self, mbox: Mailbox) {
-        self.0.push(mbox);
-    }
-
-    /// Extracts the first [`Mailbox`] if it exists.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lettre::{
-    ///     message::{Mailbox, Mailboxes},
-    ///     Address,
-    /// };
-    ///
-    /// # use std::error::Error;
-    /// # fn main() -> Result<(), Box<dyn Error>> {
-    /// let empty = Mailboxes::new();
-    /// assert!(empty.into_single().is_none());
-    ///
-    /// let mut mailboxes = Mailboxes::new();
-    /// let address = Address::new("example", "email.com")?;
-    ///
-    /// mailboxes.push(Mailbox::new(None, address));
-    /// assert!(mailboxes.into_single().is_some());
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn into_single(self) -> Option<Mailbox> {
-        self.into()
-    }
-
-    /// Creates an iterator over the [`Mailbox`] instances that are currently stored.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lettre::{
-    ///     message::{Mailbox, Mailboxes},
-    ///     Address,
-    /// };
-    ///
-    /// # use std::error::Error;
-    /// # fn main() -> Result<(), Box<dyn Error>> {
-    /// let mut mailboxes = Mailboxes::new();
-    ///
-    /// let address = Address::new("example", "email.com")?;
-    /// mailboxes.push(Mailbox::new(None, address));
-    ///
-    /// let address = Address::new("example", "email.com")?;
-    /// mailboxes.push(Mailbox::new(None, address));
-    ///
-    /// let mut iter = mailboxes.iter();
-    ///
-    /// assert!(iter.next().is_some());
-    /// assert!(iter.next().is_some());
-    ///
-    /// assert!(iter.next().is_none());
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn iter(&self) -> Iter<'_, Mailbox> {
-        self.0.iter()
-    }
-}
-
-impl Default for Mailboxes {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl From<Mailbox> for Mailboxes {
-    fn from(mailbox: Mailbox) -> Self {
-        Mailboxes(vec![mailbox])
-    }
-}
-
-impl From<Mailboxes> for Option<Mailbox> {
-    fn from(mailboxes: Mailboxes) -> Option<Mailbox> {
-        mailboxes.into_iter().next()
-    }
-}
-
-impl From<Vec<Mailbox>> for Mailboxes {
-    fn from(vec: Vec<Mailbox>) -> Self {
-        Mailboxes(vec)
-    }
-}
-
-impl From<Mailboxes> for Vec<Mailbox> {
-    fn from(mailboxes: Mailboxes) -> Vec<Mailbox> {
-        mailboxes.0
-    }
-}
-
-impl IntoIterator for Mailboxes {
-    type Item = Mailbox;
-    type IntoIter = ::std::vec::IntoIter<Mailbox>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.0.into_iter()
-    }
-}
-
-impl Extend<Mailbox> for Mailboxes {
-    fn extend<T: IntoIterator<Item = Mailbox>>(&mut self, iter: T) {
-        for elem in iter {
-            self.0.push(elem);
-        }
-    }
-}
-
-impl Display for Mailboxes {
-    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
-        let mut iter = self.iter();
-
-        if let Some(mbox) = iter.next() {
-            mbox.fmt(f)?;
-
-            for mbox in iter {
-                f.write_str(", ")?;
-                mbox.fmt(f)?;
-            }
-        }
-
-        Ok(())
-    }
-}
-
-impl FromStr for Mailboxes {
-    type Err = AddressError;
-
-    fn from_str(src: &str) -> Result<Self, Self::Err> {
-        src.split(',')
-            .map(|m| m.trim().parse())
-            .collect::<Result<Vec<_>, _>>()
-            .map(Mailboxes)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::Mailbox;
-    use std::convert::TryInto;
-
-    #[test]
-    fn mailbox_format_address_only() {
-        assert_eq!(
-            format!(
-                "{}",
-                Mailbox::new(None, "kayo@example.com".parse().unwrap())
-            ),
-            "kayo@example.com"
-        );
-    }
-
-    #[test]
-    fn mailbox_format_address_with_name() {
-        assert_eq!(
-            format!(
-                "{}",
-                Mailbox::new(Some("K.".into()), "kayo@example.com".parse().unwrap())
-            ),
-            "K. <kayo@example.com>"
-        );
-    }
-
-    #[test]
-    fn format_address_with_empty_name() {
-        assert_eq!(
-            format!(
-                "{}",
-                Mailbox::new(Some("".into()), "kayo@example.com".parse().unwrap())
-            ),
-            "kayo@example.com"
-        );
-    }
-
-    #[test]
-    fn format_address_with_name_trim() {
-        assert_eq!(
-            format!(
-                "{}",
-                Mailbox::new(Some(" K. ".into()), "kayo@example.com".parse().unwrap())
-            ),
-            "K. <kayo@example.com>"
-        );
-    }
-
-    #[test]
-    fn parse_address_only() {
-        assert_eq!(
-            "kayo@example.com".parse(),
-            Ok(Mailbox::new(None, "kayo@example.com".parse().unwrap()))
-        );
-    }
-
-    #[test]
-    fn parse_address_with_name() {
-        assert_eq!(
-            "K. <kayo@example.com>".parse(),
-            Ok(Mailbox::new(
-                Some("K.".into()),
-                "kayo@example.com".parse().unwrap()
-            ))
-        );
-    }
-
-    #[test]
-    fn parse_address_with_empty_name() {
-        assert_eq!(
-            "<kayo@example.com>".parse(),
-            Ok(Mailbox::new(None, "kayo@example.com".parse().unwrap()))
-        );
-    }
-
-    #[test]
-    fn parse_address_with_empty_name_trim() {
-        assert_eq!(
-            " <kayo@example.com>".parse(),
-            Ok(Mailbox::new(None, "kayo@example.com".parse().unwrap()))
-        );
-    }
-
-    #[test]
-    fn parse_address_from_tuple() {
-        assert_eq!(
-            ("K.".to_string(), "kayo@example.com".to_string()).try_into(),
-            Ok(Mailbox::new(
-                Some("K.".into()),
-                "kayo@example.com".parse().unwrap()
-            ))
-        );
-    }
-}

src/message/mimebody.rs

@@ -1,708 +0,0 @@
-use std::io::Write;
-
-use crate::message::{
-    header::{self, ContentTransferEncoding, ContentType, Header, Headers},
-    EmailFormat, IntoBody,
-};
-use mime::Mime;
-use std::iter::repeat_with;
-
-/// MIME part variants
-#[derive(Debug, Clone)]
-pub(super) enum Part {
-    /// Single part with content
-    Single(SinglePart),
-
-    /// Multiple parts of content
-    Multi(MultiPart),
-}
-
-impl EmailFormat for Part {
-    fn format(&self, out: &mut Vec<u8>) {
-        match self {
-            Part::Single(part) => part.format(out),
-            Part::Multi(part) => part.format(out),
-        }
-    }
-}
-
-/// Creates builder for single part
-#[derive(Debug, Clone)]
-pub struct SinglePartBuilder {
-    headers: Headers,
-}
-
-impl SinglePartBuilder {
-    /// Creates a default singlepart builder
-    pub fn new() -> Self {
-        Self {
-            headers: Headers::new(),
-        }
-    }
-
-    /// Set the header to singlepart
-    pub fn header<H: Header>(mut self, header: H) -> Self {
-        self.headers.set(header);
-        self
-    }
-
-    /// Set the Content-Type header of the singlepart
-    pub fn content_type(mut self, content_type: ContentType) -> Self {
-        self.headers.set(content_type);
-        self
-    }
-
-    /// Build singlepart using body
-    pub fn body<T: IntoBody>(mut self, body: T) -> SinglePart {
-        let maybe_encoding = self.headers.get::<ContentTransferEncoding>();
-        let body = body.into_body(maybe_encoding);
-
-        self.headers.set(body.encoding());
-
-        SinglePart {
-            headers: self.headers,
-            body: body.into_vec(),
-        }
-    }
-}
-
-impl Default for SinglePartBuilder {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-/// Single part
-///
-/// # Example
-///
-/// ```
-/// use lettre::message::{header, SinglePart};
-///
-/// # use std::error::Error;
-/// # fn main() -> Result<(), Box<dyn Error>> {
-/// let part = SinglePart::builder()
-///     .header(header::ContentType::TEXT_PLAIN)
-///     .body(String::from("Текст письма в уникоде"));
-/// # Ok(())
-/// # }
-/// ```
-#[derive(Debug, Clone)]
-pub struct SinglePart {
-    headers: Headers,
-    body: Vec<u8>,
-}
-
-impl SinglePart {
-    /// Creates a builder for singlepart
-    #[inline]
-    pub fn builder() -> SinglePartBuilder {
-        SinglePartBuilder::new()
-    }
-
-    /// Directly create a `SinglePart` from an plain UTF-8 content
-    pub fn plain<T: IntoBody>(body: T) -> Self {
-        Self::builder()
-            .header(header::ContentType::TEXT_PLAIN)
-            .body(body)
-    }
-
-    /// Directly create a `SinglePart` from an UTF-8 HTML content
-    pub fn html<T: IntoBody>(body: T) -> Self {
-        Self::builder()
-            .header(header::ContentType::TEXT_HTML)
-            .body(body)
-    }
-
-    /// Get the headers from singlepart
-    #[inline]
-    pub fn headers(&self) -> &Headers {
-        &self.headers
-    }
-
-    /// Get the encoded body
-    #[inline]
-    pub fn raw_body(&self) -> &[u8] {
-        &self.body
-    }
-
-    /// Get message content formatted for sending
-    pub fn formatted(&self) -> Vec<u8> {
-        let mut out = Vec::new();
-        self.format(&mut out);
-        out
-    }
-}
-
-impl EmailFormat for SinglePart {
-    fn format(&self, out: &mut Vec<u8>) {
-        write!(out, "{}", self.headers)
-            .expect("A Write implementation panicked while formatting headers");
-        out.extend_from_slice(b"\r\n");
-        out.extend_from_slice(&self.body);
-        out.extend_from_slice(b"\r\n");
-    }
-}
-
-/// The kind of multipart
-#[derive(Debug, Clone)]
-pub enum MultiPartKind {
-    /// Mixed kind to combine unrelated content parts
-    ///
-    /// For example this kind can be used to mix email message and attachments.
-    Mixed,
-
-    /// Alternative kind to join several variants of same email contents.
-    ///
-    /// That kind is recommended to use for joining plain (text) and rich (HTML) messages into single email message.
-    Alternative,
-
-    /// Related kind to mix content and related resources.
-    ///
-    /// For example, you can include images into HTML content using that.
-    Related,
-
-    /// Encrypted kind for encrypted messages
-    Encrypted { protocol: String },
-
-    /// Signed kind for signed messages
-    Signed { protocol: String, micalg: String },
-}
-
-/// Create a random MIME boundary.
-/// (Not cryptographically random)
-fn make_boundary() -> String {
-    repeat_with(fastrand::alphanumeric).take(40).collect()
-}
-
-impl MultiPartKind {
-    pub(crate) fn to_mime<S: Into<String>>(&self, boundary: Option<S>) -> Mime {
-        let boundary = boundary.map_or_else(make_boundary, Into::into);
-
-        format!(
-            "multipart/{}; boundary=\"{}\"{}",
-            match self {
-                Self::Mixed => "mixed",
-                Self::Alternative => "alternative",
-                Self::Related => "related",
-                Self::Encrypted { .. } => "encrypted",
-                Self::Signed { .. } => "signed",
-            },
-            boundary,
-            match self {
-                Self::Encrypted { protocol } => format!("; protocol=\"{}\"", protocol),
-                Self::Signed { protocol, micalg } =>
-                    format!("; protocol=\"{}\"; micalg=\"{}\"", protocol, micalg),
-                _ => String::new(),
-            }
-        )
-        .parse()
-        .unwrap()
-    }
-
-    fn from_mime(m: &Mime) -> Option<Self> {
-        match m.subtype().as_ref() {
-            "mixed" => Some(Self::Mixed),
-            "alternative" => Some(Self::Alternative),
-            "related" => Some(Self::Related),
-            "signed" => m.get_param("protocol").and_then(|p| {
-                m.get_param("micalg").map(|micalg| Self::Signed {
-                    protocol: p.as_str().to_owned(),
-                    micalg: micalg.as_str().to_owned(),
-                })
-            }),
-            "encrypted" => m.get_param("protocol").map(|p| Self::Encrypted {
-                protocol: p.as_str().to_owned(),
-            }),
-            _ => None,
-        }
-    }
-}
-
-/// Multipart builder
-#[derive(Debug, Clone)]
-pub struct MultiPartBuilder {
-    headers: Headers,
-}
-
-impl MultiPartBuilder {
-    /// Creates default multipart builder
-    pub fn new() -> Self {
-        Self {
-            headers: Headers::new(),
-        }
-    }
-
-    /// Set a header
-    pub fn header<H: Header>(mut self, header: H) -> Self {
-        self.headers.set(header);
-        self
-    }
-
-    /// Set `Content-Type` header using [`MultiPartKind`]
-    pub fn kind(self, kind: MultiPartKind) -> Self {
-        self.header(ContentType::from_mime(kind.to_mime::<String>(None)))
-    }
-
-    /// Set custom boundary
-    pub fn boundary<S: Into<String>>(self, boundary: S) -> Self {
-        let kind = {
-            let content_type = self.headers.get::<ContentType>().unwrap();
-            MultiPartKind::from_mime(content_type.as_ref()).unwrap()
-        };
-        let mime = kind.to_mime(Some(boundary));
-        self.header(ContentType::from_mime(mime))
-    }
-
-    /// Creates multipart without parts
-    pub fn build(self) -> MultiPart {
-        MultiPart {
-            headers: self.headers,
-            parts: Vec::new(),
-        }
-    }
-
-    /// Creates multipart using singlepart
-    pub fn singlepart(self, part: SinglePart) -> MultiPart {
-        self.build().singlepart(part)
-    }
-
-    /// Creates multipart using multipart
-    pub fn multipart(self, part: MultiPart) -> MultiPart {
-        self.build().multipart(part)
-    }
-}
-
-impl Default for MultiPartBuilder {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-/// Multipart variant with parts
-#[derive(Debug, Clone)]
-pub struct MultiPart {
-    headers: Headers,
-    parts: Vec<Part>,
-}
-
-impl MultiPart {
-    /// Creates multipart builder
-    pub fn builder() -> MultiPartBuilder {
-        MultiPartBuilder::new()
-    }
-
-    /// Creates mixed multipart builder
-    ///
-    /// Shortcut for `MultiPart::builder().kind(MultiPartKind::Mixed)`
-    pub fn mixed() -> MultiPartBuilder {
-        MultiPart::builder().kind(MultiPartKind::Mixed)
-    }
-
-    /// Creates alternative multipart builder
-    ///
-    /// Shortcut for `MultiPart::builder().kind(MultiPartKind::Alternative)`
-    pub fn alternative() -> MultiPartBuilder {
-        MultiPart::builder().kind(MultiPartKind::Alternative)
-    }
-
-    /// Creates related multipart builder
-    ///
-    /// Shortcut for `MultiPart::builder().kind(MultiPartKind::Related)`
-    pub fn related() -> MultiPartBuilder {
-        MultiPart::builder().kind(MultiPartKind::Related)
-    }
-
-    /// Creates encrypted multipart builder
-    ///
-    /// Shortcut for `MultiPart::builder().kind(MultiPartKind::Encrypted{ protocol })`
-    pub fn encrypted(protocol: String) -> MultiPartBuilder {
-        MultiPart::builder().kind(MultiPartKind::Encrypted { protocol })
-    }
-
-    /// Creates signed multipart builder
-    ///
-    /// Shortcut for `MultiPart::builder().kind(MultiPartKind::Signed{ protocol, micalg })`
-    pub fn signed(protocol: String, micalg: String) -> MultiPartBuilder {
-        MultiPart::builder().kind(MultiPartKind::Signed { protocol, micalg })
-    }
-
-    /// Alias for HTML and plain text versions of an email
-    pub fn alternative_plain_html<T: IntoBody, V: IntoBody>(plain: T, html: V) -> Self {
-        Self::alternative()
-            .singlepart(SinglePart::plain(plain))
-            .singlepart(SinglePart::html(html))
-    }
-
-    /// Add single part to multipart
-    pub fn singlepart(mut self, part: SinglePart) -> Self {
-        self.parts.push(Part::Single(part));
-        self
-    }
-
-    /// Add multi part to multipart
-    pub fn multipart(mut self, part: MultiPart) -> Self {
-        self.parts.push(Part::Multi(part));
-        self
-    }
-
-    /// Get the boundary of multipart contents
-    pub fn boundary(&self) -> String {
-        let content_type = self.headers.get::<ContentType>().unwrap();
-        content_type
-            .as_ref()
-            .get_param("boundary")
-            .unwrap()
-            .as_str()
-            .into()
-    }
-
-    /// Get the headers from the multipart
-    pub fn headers(&self) -> &Headers {
-        &self.headers
-    }
-
-    /// Get a mutable reference to the headers
-    pub fn headers_mut(&mut self) -> &mut Headers {
-        &mut self.headers
-    }
-
-    /// Get message content formatted for SMTP
-    pub fn formatted(&self) -> Vec<u8> {
-        let mut out = Vec::new();
-        self.format(&mut out);
-        out
-    }
-}
-
-impl EmailFormat for MultiPart {
-    fn format(&self, out: &mut Vec<u8>) {
-        write!(out, "{}", self.headers)
-            .expect("A Write implementation panicked while formatting headers");
-        out.extend_from_slice(b"\r\n");
-
-        let boundary = self.boundary();
-
-        for part in &self.parts {
-            out.extend_from_slice(b"--");
-            out.extend_from_slice(boundary.as_bytes());
-            out.extend_from_slice(b"\r\n");
-            part.format(out);
-        }
-
-        out.extend_from_slice(b"--");
-        out.extend_from_slice(boundary.as_bytes());
-        out.extend_from_slice(b"--\r\n");
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::message::header;
-
-    #[test]
-    fn single_part_binary() {
-        let part = SinglePart::builder()
-            .header(header::ContentType::TEXT_PLAIN)
-            .header(header::ContentTransferEncoding::Binary)
-            .body(String::from("Текст письма в уникоде"));
-
-        assert_eq!(
-            String::from_utf8(part.formatted()).unwrap(),
-            concat!(
-                "Content-Type: text/plain; charset=utf-8\r\n",
-                "Content-Transfer-Encoding: binary\r\n",
-                "\r\n",
-                "Текст письма в уникоде\r\n"
-            )
-        );
-    }
-
-    #[test]
-    fn single_part_quoted_printable() {
-        let part = SinglePart::builder()
-            .header(header::ContentType::TEXT_PLAIN)
-            .header(header::ContentTransferEncoding::QuotedPrintable)
-            .body(String::from("Текст письма в уникоде"));
-
-        assert_eq!(
-            String::from_utf8(part.formatted()).unwrap(),
-            concat!(
-                "Content-Type: text/plain; charset=utf-8\r\n",
-                "Content-Transfer-Encoding: quoted-printable\r\n",
-                "\r\n",
-                "=D0=A2=D0=B5=D0=BA=D1=81=D1=82 =D0=BF=D0=B8=D1=81=D1=8C=D0=BC=D0=B0 =D0=B2 =\r\n",
-                "=D1=83=D0=BD=D0=B8=D0=BA=D0=BE=D0=B4=D0=B5\r\n"
-            )
-        );
-    }
-
-    #[test]
-    fn single_part_base64() {
-        let part = SinglePart::builder()
-            .header(header::ContentType::TEXT_PLAIN)
-            .header(header::ContentTransferEncoding::Base64)
-            .body(String::from("Текст письма в уникоде"));
-
-        assert_eq!(
-            String::from_utf8(part.formatted()).unwrap(),
-            concat!(
-                "Content-Type: text/plain; charset=utf-8\r\n",
-                "Content-Transfer-Encoding: base64\r\n",
-                "\r\n",
-                "0KLQtdC60YHRgiDQv9C40YHRjNC80LAg0LIg0YPQvdC40LrQvtC00LU=\r\n"
-            )
-        );
-    }
-
-    #[test]
-    fn multi_part_mixed() {
-        let part = MultiPart::mixed()
-            .boundary("0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1")
-            .singlepart(
-                SinglePart::builder()
-                    .header(header::ContentType::TEXT_PLAIN)
-                    .header(header::ContentTransferEncoding::Binary)
-                    .body(String::from("Текст письма в уникоде")),
-            )
-            .singlepart(
-                SinglePart::builder()
-                    .header(header::ContentType::TEXT_PLAIN)
-                    .header(header::ContentDisposition::attachment("example.c"))
-                    .header(header::ContentTransferEncoding::Binary)
-                    .body(String::from("int main() { return 0; }")),
-            );
-
-        assert_eq!(
-            String::from_utf8(part.formatted()).unwrap(),
-            concat!(
-                "Content-Type: multipart/mixed; \r\n",
-                " boundary=\"0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\"\r\n",
-                "\r\n",
-                "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
-                "Content-Type: text/plain; charset=utf-8\r\n",
-                "Content-Transfer-Encoding: binary\r\n",
-                "\r\n",
-                "Текст письма в уникоде\r\n",
-                "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
-                "Content-Type: text/plain; charset=utf-8\r\n",
-                "Content-Disposition: attachment; filename=\"example.c\"\r\n",
-                "Content-Transfer-Encoding: binary\r\n",
-                "\r\n",
-                "int main() { return 0; }\r\n",
-                "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1--\r\n"
-            )
-        );
-    }
-    #[test]
-    fn multi_part_encrypted() {
-        let part = MultiPart::encrypted("application/pgp-encrypted".to_owned())
-            .boundary("0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1")
-            .singlepart(
-                SinglePart::builder()
-                    .header(header::ContentType::parse("application/pgp-encrypted").unwrap())
-                    .body(String::from("Version: 1")),
-            )
-            .singlepart(
-                SinglePart::builder()
-                    .header(
-                        ContentType::parse("application/octet-stream; name=\"encrypted.asc\"")
-                            .unwrap(),
-                    )
-                    .header(header::ContentDisposition::inline_with_name(
-                        "encrypted.asc",
-                    ))
-                    .body(String::from(concat!(
-                        "-----BEGIN PGP MESSAGE-----\r\n",
-                        "wV4D0dz5vDXklO8SAQdA5lGX1UU/eVQqDxNYdHa7tukoingHzqUB6wQssbMfHl8w\r\n",
-                        "...\r\n",
-                        "-----END PGP MESSAGE-----\r\n"
-                    ))),
-            );
-
-        assert_eq!(
-            String::from_utf8(part.formatted()).unwrap(),
-            concat!(
-                "Content-Type: multipart/encrypted; \r\n",
-                " boundary=\"0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\"; \r\n",
-                " protocol=\"application/pgp-encrypted\"\r\n",
-                "\r\n",
-                "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
-                "Content-Type: application/pgp-encrypted\r\n",
-                "Content-Transfer-Encoding: 7bit\r\n",
-                "\r\n",
-                "Version: 1\r\n",
-                "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
-                "Content-Type: application/octet-stream; name=\"encrypted.asc\"\r\n",
-                "Content-Disposition: inline; filename=\"encrypted.asc\"\r\n",
-                "Content-Transfer-Encoding: 7bit\r\n",
-                "\r\n",
-                "-----BEGIN PGP MESSAGE-----\r\n",
-                "wV4D0dz5vDXklO8SAQdA5lGX1UU/eVQqDxNYdHa7tukoingHzqUB6wQssbMfHl8w\r\n",
-                "...\r\n",
-                "-----END PGP MESSAGE-----\r\n",
-                "\r\n",
-                "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1--\r\n"
-            )
-        );
-    }
-    #[test]
-    fn multi_part_signed() {
-        let part = MultiPart::signed(
-            "application/pgp-signature".to_owned(),
-            "pgp-sha256".to_owned(),
-        )
-        .boundary("0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1")
-        .singlepart(
-            SinglePart::builder()
-                .header(header::ContentType::TEXT_PLAIN)
-                .body(String::from("Test email for signature")),
-        )
-        .singlepart(
-            SinglePart::builder()
-                .header(
-                    ContentType::parse("application/pgp-signature; name=\"signature.asc\"")
-                        .unwrap(),
-                )
-                .header(header::ContentDisposition::attachment("signature.asc"))
-                .body(String::from(concat!(
-                    "-----BEGIN PGP SIGNATURE-----\r\n",
-                    "\r\n",
-                    "iHUEARYIAB0WIQTNsp3S/GbdE0KoiQ+IGQOscREZuQUCXyOzDAAKCRCIGQOscREZ\r\n",
-                    "udgDAQCv3FJ3QWW5bRaGZAa0Ug6vASFdkvDMKoRwcoFnHPthjQEAiQ8skkIyE2GE\r\n",
-                    "PoLpAXiKpT+NU8S8+8dfvwutnb4dSwM=\r\n",
-                    "=3FYZ\r\n",
-                    "-----END PGP SIGNATURE-----\r\n",
-                ))),
-        );
-
-        assert_eq!(
-            String::from_utf8(part.formatted()).unwrap(),
-            concat!(
-                "Content-Type: multipart/signed; \r\n",
-                " boundary=\"0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\"; \r\n",
-                " protocol=\"application/pgp-signature\";",
-                " micalg=\"pgp-sha256\"\r\n",
-                "\r\n",
-                "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
-                "Content-Type: text/plain; charset=utf-8\r\n",
-                "Content-Transfer-Encoding: 7bit\r\n",
-                "\r\n",
-                "Test email for signature\r\n",
-                "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
-                "Content-Type: application/pgp-signature; name=\"signature.asc\"\r\n",
-                "Content-Disposition: attachment; filename=\"signature.asc\"\r\n",
-                "Content-Transfer-Encoding: 7bit\r\n",
-                "\r\n",
-                "-----BEGIN PGP SIGNATURE-----\r\n",
-                "\r\n",
-                "iHUEARYIAB0WIQTNsp3S/GbdE0KoiQ+IGQOscREZuQUCXyOzDAAKCRCIGQOscREZ\r\n",
-                "udgDAQCv3FJ3QWW5bRaGZAa0Ug6vASFdkvDMKoRwcoFnHPthjQEAiQ8skkIyE2GE\r\n",
-                "PoLpAXiKpT+NU8S8+8dfvwutnb4dSwM=\r\n",
-                "=3FYZ\r\n",
-                "-----END PGP SIGNATURE-----\r\n",
-                "\r\n",
-                "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1--\r\n"
-            )
-        );
-    }
-
-    #[test]
-    fn multi_part_alternative() {
-        let part = MultiPart::alternative()
-            .boundary("0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1")
-            .singlepart(SinglePart::builder()
-                             .header(header::ContentType::TEXT_PLAIN)
-                             .header(header::ContentTransferEncoding::Binary)
-                             .body(String::from("Текст письма в уникоде")))
-            .singlepart(SinglePart::builder()
-                             .header(header::ContentType::TEXT_HTML)
-                             .header(header::ContentTransferEncoding::Binary)
-                             .body(String::from("<p>Текст <em>письма</em> в <a href=\"https://ru.wikipedia.org/wiki/Юникод\">уникоде</a><p>")));
-
-        assert_eq!(String::from_utf8(part.formatted()).unwrap(),
-                   concat!("Content-Type: multipart/alternative; \r\n",
-                           " boundary=\"0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\"\r\n",
-                           "\r\n",
-                           "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
-                           "Content-Type: text/plain; charset=utf-8\r\n",
-                           "Content-Transfer-Encoding: binary\r\n",
-                           "\r\n",
-                           "Текст письма в уникоде\r\n",
-                           "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
-                           "Content-Type: text/html; charset=utf-8\r\n",
-                           "Content-Transfer-Encoding: binary\r\n",
-                           "\r\n",
-                           "<p>Текст <em>письма</em> в <a href=\"https://ru.wikipedia.org/wiki/Юникод\">уникоде</a><p>\r\n",
-                           "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1--\r\n"));
-    }
-
-    #[test]
-    fn multi_part_mixed_related() {
-        let part = MultiPart::mixed()
-            .boundary("0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1")
-            .multipart(MultiPart::related()
-                            .boundary("0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1")
-                            .singlepart(SinglePart::builder()
-                                             .header(header::ContentType::TEXT_HTML)
-                                             .header(header::ContentTransferEncoding::Binary)
-                                             .body(String::from("<p>Текст <em>письма</em> в <a href=\"https://ru.wikipedia.org/wiki/Юникод\">уникоде</a><p>")))
-                            .singlepart(SinglePart::builder()
-                                             .header(header::ContentType::parse("image/png").unwrap())
-                                             .header(header::ContentLocation::from(String::from("/image.png")))
-                                             .header(header::ContentTransferEncoding::Base64)
-                                             .body(String::from("1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"))))
-            .singlepart(SinglePart::builder()
-                             .header(header::ContentType::TEXT_PLAIN)
-                             .header(header::ContentDisposition::attachment("example.c"))
-                             .header(header::ContentTransferEncoding::Binary)
-                             .body(String::from("int main() { return 0; }")));
-
-        assert_eq!(String::from_utf8(part.formatted()).unwrap(),
-                   concat!("Content-Type: multipart/mixed; \r\n",
-                           " boundary=\"0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\"\r\n",
-                           "\r\n",
-                           "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
-                           "Content-Type: multipart/related; \r\n",
-                           " boundary=\"0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\"\r\n",
-                           "\r\n",
-                           "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
-                           "Content-Type: text/html; charset=utf-8\r\n",
-                           "Content-Transfer-Encoding: binary\r\n",
-                           "\r\n",
-                           "<p>Текст <em>письма</em> в <a href=\"https://ru.wikipedia.org/wiki/Юникод\">уникоде</a><p>\r\n",
-                           "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
-                           "Content-Type: image/png\r\n",
-                           "Content-Location: /image.png\r\n",
-                           "Content-Transfer-Encoding: base64\r\n",
-                           "\r\n",
-                           "MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3\r\n",
-                           "ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0\r\n",
-                           "NTY3ODkwMTIzNDU2Nzg5MA==\r\n",
-                           "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1--\r\n",
-                           "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1\r\n",
-                           "Content-Type: text/plain; charset=utf-8\r\n",
-                           "Content-Disposition: attachment; filename=\"example.c\"\r\n",
-                           "Content-Transfer-Encoding: binary\r\n",
-                           "\r\n",
-                           "int main() { return 0; }\r\n",
-                           "--0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1--\r\n"));
-    }
-
-    #[test]
-    fn test_make_boundary() {
-        let mut boundaries = std::collections::HashSet::with_capacity(10);
-        for _ in 0..1000 {
-            boundaries.insert(make_boundary());
-        }
-
-        // Ensure there are no duplicates
-        assert_eq!(1000, boundaries.len());
-
-        // Ensure correct length
-        for boundary in boundaries {
-            assert_eq!(40, boundary.len());
-        }
-    }
-}

src/message/mod.rs

@@ -1,648 +0,0 @@
-//! Provides a strongly typed way to build emails
-//!
-//! ## Usage
-//!
-//! This section demonstrates how to build messages.
-//!
-//! <!--
-//! style for <details><summary>Blablabla</summary> Lots of stuff</details>
-//! borrowed from https://docs.rs/time/0.2.23/src/time/lib.rs.html#49-54
-//! -->
-//! <style>
-//! summary, details:not([open]) { cursor: pointer; }
-//! summary { display: list-item; }
-//! summary::marker { content: '▶ '; }
-//! details[open] summary::marker { content: '▼ '; }
-//! </style>
-//!
-//!
-//! ### Plain body
-//!
-//! The easiest way of creating a message, which uses a plain text body.
-//!
-//! ```rust
-//! use lettre::message::Message;
-//!
-//! # use std::error::Error;
-//! # fn main() -> Result<(), Box<dyn Error>> {
-//! let m = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
-//!     .subject("Happy new year")
-//!     .body(String::from("Be happy!"))?;
-//! # Ok(())
-//! # }
-//! ```
-//!
-//! Which produces:
-//! <details>
-//! <summary>Click to expand</summary>
-//!
-//! ```sh
-//! From: NoBody <nobody@domain.tld>
-//! Reply-To: Yuin <yuin@domain.tld>
-//! To: Hei <hei@domain.tld>
-//! Subject: Happy new year
-//! Date: Sat, 12 Dec 2020 16:33:19 GMT
-//! Content-Transfer-Encoding: 7bit
-//!
-//! Be happy!
-//! ```
-//! </details>
-//! <br />
-//!
-//! The unicode header data is encoded using _UTF8-Base64_ encoding, when necessary.
-//!
-//! The `Content-Transfer-Encoding` is chosen based on the best encoding
-//! available for the given body, between `7bit`, `quoted-printable` and `base64`.
-//!
-//! ### Plain and HTML body
-//!
-//! Uses a MIME body to include both plain text and HTML versions of the body.
-//!
-//! ```rust
-//! # use std::error::Error;
-//! use lettre::message::{header, Message, MultiPart, SinglePart};
-//!
-//! # fn main() -> Result<(), Box<dyn Error>> {
-//! let m = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
-//!     .subject("Happy new year")
-//!     .multipart(MultiPart::alternative_plain_html(
-//!         String::from("Hello, world! :)"),
-//!         String::from("<p><b>Hello</b>, <i>world</i>! <img src=\"cid:123\"></p>"),
-//!     ))?;
-//! # Ok(())
-//! # }
-//! ```
-//!
-//! Which produces:
-//! <details>
-//! <summary>Click to expand</summary>
-//!
-//! ```sh
-//! From: NoBody <nobody@domain.tld>
-//! Reply-To: Yuin <yuin@domain.tld>
-//! To: Hei <hei@domain.tld>
-//! Subject: Happy new year
-//! MIME-Version: 1.0
-//! Date: Sat, 12 Dec 2020 16:33:19 GMT
-//! Content-Type: multipart/alternative; boundary="0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1"
-//!
-//! --0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1
-//! Content-Type: text/plain; charset=utf8
-//! Content-Transfer-Encoding: 7bit
-//!
-//! Hello, world! :)
-//! --0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1
-//! Content-Type: text/html; charset=utf8
-//! Content-Transfer-Encoding: 7bit
-//!
-//! <p><b>Hello</b>, <i>world</i>! <img src="cid:123"></p>
-//! --0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1--
-//! ```
-//! </details>
-//!
-//! ### Complex MIME body
-//!
-//! This example shows how to include both plain and HTML versions of the body,
-//! attachments and inlined images.
-//!
-//! ```rust
-//! # use std::error::Error;
-//! use lettre::message::{header, Attachment, Body, Message, MultiPart, SinglePart};
-//! use std::fs;
-//!
-//! # fn main() -> Result<(), Box<dyn Error>> {
-//! let image = fs::read("docs/lettre.png")?;
-//! // this image_body can be cloned and reused between emails.
-//! // since `Body` holds a pre-encoded body, reusing it means avoiding having
-//! // to re-encode the same body for every email (this clearly only applies
-//! // when sending multiple emails with the same attachment).
-//! let image_body = Body::new(image);
-//!
-//! let m = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
-//!     .subject("Happy new year")
-//!     .multipart(
-//!         MultiPart::mixed()
-//!             .multipart(
-//!                 MultiPart::alternative()
-//!                     .singlepart(SinglePart::plain(String::from("Hello, world! :)")))
-//!                     .multipart(
-//!                         MultiPart::related()
-//!                             .singlepart(SinglePart::html(String::from(
-//!                                 "<p><b>Hello</b>, <i>world</i>! <img src=cid:123></p>",
-//!                             )))
-//!                             .singlepart(
-//!                                 Attachment::new_inline(String::from("123"))
-//!                                     .body(image_body, "image/png".parse().unwrap()),
-//!                             ),
-//!                     ),
-//!             )
-//!             .singlepart(Attachment::new(String::from("example.rs")).body(
-//!                 String::from("fn main() { println!(\"Hello, World!\") }"),
-//!                 "text/plain".parse().unwrap(),
-//!             )),
-//!     )?;
-//! # Ok(())
-//! # }
-//! ```
-//!
-//! Which produces:
-//! <details>
-//! <summary>Click to expand</summary>
-//!
-//! ```sh
-//! From: NoBody <nobody@domain.tld>
-//! Reply-To: Yuin <yuin@domain.tld>
-//! To: Hei <hei@domain.tld>
-//! Subject: Happy new year
-//! MIME-Version: 1.0
-//! Date: Sat, 12 Dec 2020 16:30:45 GMT
-//! Content-Type: multipart/mixed; boundary="0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1"
-//!
-//! --0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1
-//! Content-Type: multipart/alternative; boundary="EyXdAZIgZuyUjAounq4Aj44a6MpJfqCKhm6pE1zk"
-//!
-//! --EyXdAZIgZuyUjAounq4Aj44a6MpJfqCKhm6pE1zk
-//! Content-Type: text/plain; charset=utf8
-//! Content-Transfer-Encoding: 7bit
-//!
-//! Hello, world! :)
-//! --EyXdAZIgZuyUjAounq4Aj44a6MpJfqCKhm6pE1zk
-//! Content-Type: multipart/related; boundary="eM5Z18WZVOQsqi5GQ71XGAXk6NNvHUA1Xv1FWrXr"
-//!
-//! --eM5Z18WZVOQsqi5GQ71XGAXk6NNvHUA1Xv1FWrXr
-//! Content-Type: text/html; charset=utf8
-//! Content-Transfer-Encoding: 7bit
-//!
-//! <p><b>Hello</b>, <i>world</i>! <img src=cid:123></p>
-//! --eM5Z18WZVOQsqi5GQ71XGAXk6NNvHUA1Xv1FWrXr
-//! Content-Type: image/png
-//! Content-Disposition: inline
-//! Content-ID: <123>
-//! Content-Transfer-Encoding: base64
-//!
-//! PHNtaWxlLXJhdy1pbWFnZS1kYXRhPg==
-//! --eM5Z18WZVOQsqi5GQ71XGAXk6NNvHUA1Xv1FWrXr--
-//! --EyXdAZIgZuyUjAounq4Aj44a6MpJfqCKhm6pE1zk--
-//! --0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1
-//! Content-Type: text/plain; charset=utf8
-//! Content-Disposition: attachment; filename="example.rs"
-//! Content-Transfer-Encoding: 7bit
-//!
-//! fn main() { println!("Hello, World!") }
-//! --0oVZ2r6AoLAhLlb0gPNSKy6BEqdS2IfwxrcbUuo1--
-//! ```
-//! </details>
-
-use std::{convert::TryFrom, io::Write, iter, time::SystemTime};
-
-pub use attachment::Attachment;
-pub use body::{Body, IntoBody, MaybeString};
-pub use mailbox::*;
-pub use mimebody::*;
-
-mod attachment;
-mod body;
-pub mod header;
-mod mailbox;
-mod mimebody;
-
-use crate::{
-    address::Envelope,
-    message::header::{ContentTransferEncoding, Header, Headers, MailboxesHeader},
-    Error as EmailError,
-};
-
-const DEFAULT_MESSAGE_ID_DOMAIN: &str = "localhost";
-
-/// Something that can be formatted as an email message
-trait EmailFormat {
-    // Use a writer?
-    fn format(&self, out: &mut Vec<u8>);
-}
-
-/// A builder for messages
-#[derive(Debug, Clone)]
-pub struct MessageBuilder {
-    headers: Headers,
-    envelope: Option<Envelope>,
-}
-
-impl MessageBuilder {
-    /// Creates a new default message builder
-    pub fn new() -> Self {
-        Self {
-            headers: Headers::new(),
-            envelope: None,
-        }
-    }
-
-    /// Set custom header to message
-    pub fn header<H: Header>(mut self, header: H) -> Self {
-        self.headers.set(header);
-        self
-    }
-
-    /// Add mailbox to header
-    pub fn mailbox<H: Header + MailboxesHeader>(self, header: H) -> Self {
-        match self.headers.get::<H>() {
-            Some(mut header_) => {
-                header_.join_mailboxes(header);
-                self.header(header_)
-            }
-            None => self.header(header),
-        }
-    }
-
-    /// Add `Date` header to message
-    ///
-    /// Shortcut for `self.header(header::Date::new(st))`.
-    pub fn date(self, st: SystemTime) -> Self {
-        self.header(header::Date::new(st))
-    }
-
-    /// Set `Date` header using current date/time
-    ///
-    /// Shortcut for `self.date(SystemTime::now())`, it is automatically inserted
-    /// if no date has been provided.
-    pub fn date_now(self) -> Self {
-        self.date(SystemTime::now())
-    }
-
-    /// Set `Subject` header to message
-    ///
-    /// Shortcut for `self.header(header::Subject(subject.into()))`.
-    pub fn subject<S: Into<String>>(self, subject: S) -> Self {
-        let s: String = subject.into();
-        self.header(header::Subject::from(s))
-    }
-
-    /// Set `MIME-Version` header to 1.0
-    ///
-    /// Shortcut for `self.header(header::MIME_VERSION_1_0)`.
-    ///
-    /// Not exposed as it is set by body methods
-    fn mime_1_0(self) -> Self {
-        self.header(header::MIME_VERSION_1_0)
-    }
-
-    /// Set `Sender` header. Should be used when providing several `From` mailboxes.
-    ///
-    /// Defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.2).
-    ///
-    /// Shortcut for `self.header(header::Sender(mbox))`.
-    pub fn sender(self, mbox: Mailbox) -> Self {
-        self.header(header::Sender::from(mbox))
-    }
-
-    /// Set or add mailbox to `From` header
-    ///
-    /// Defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.2).
-    ///
-    /// Shortcut for `self.mailbox(header::From(mbox))`.
-    pub fn from(self, mbox: Mailbox) -> Self {
-        self.mailbox(header::From::from(Mailboxes::from(mbox)))
-    }
-
-    /// Set or add mailbox to `ReplyTo` header
-    ///
-    /// Defined in [RFC5322](https://tools.ietf.org/html/rfc5322#section-3.6.2).
-    ///
-    /// Shortcut for `self.mailbox(header::ReplyTo(mbox))`.
-    pub fn reply_to(self, mbox: Mailbox) -> Self {
-        self.mailbox(header::ReplyTo(mbox.into()))
-    }
-
-    /// Set or add mailbox to `To` header
-    ///
-    /// Shortcut for `self.mailbox(header::To(mbox))`.
-    pub fn to(self, mbox: Mailbox) -> Self {
-        self.mailbox(header::To(mbox.into()))
-    }
-
-    /// Set or add mailbox to `Cc` header
-    ///
-    /// Shortcut for `self.mailbox(header::Cc(mbox))`.
-    pub fn cc(self, mbox: Mailbox) -> Self {
-        self.mailbox(header::Cc(mbox.into()))
-    }
-
-    /// Set or add mailbox to `Bcc` header
-    ///
-    /// Shortcut for `self.mailbox(header::Bcc(mbox))`.
-    pub fn bcc(self, mbox: Mailbox) -> Self {
-        self.mailbox(header::Bcc(mbox.into()))
-    }
-
-    /// Set or add message id to [`In-Reply-To`
-    /// header](https://tools.ietf.org/html/rfc5322#section-3.6.4)
-    pub fn in_reply_to(self, id: String) -> Self {
-        self.header(header::InReplyTo::from(id))
-    }
-
-    /// Set or add message id to [`References`
-    /// header](https://tools.ietf.org/html/rfc5322#section-3.6.4)
-    pub fn references(self, id: String) -> Self {
-        self.header(header::References::from(id))
-    }
-
-    /// Set [Message-ID
-    /// header](https://tools.ietf.org/html/rfc5322#section-3.6.4)
-    ///
-    /// Should generally be inserted by the mail relay.
-    ///
-    /// If `None` is provided, an id will be generated in the
-    /// `<UUID@HOSTNAME>`.
-    pub fn message_id(self, id: Option<String>) -> Self {
-        match id {
-            Some(i) => self.header(header::MessageId::from(i)),
-            None => {
-                #[cfg(feature = "hostname")]
-                let hostname = hostname::get()
-                    .map_err(|_| ())
-                    .and_then(|s| s.into_string().map_err(|_| ()))
-                    .unwrap_or_else(|_| DEFAULT_MESSAGE_ID_DOMAIN.to_string());
-                #[cfg(not(feature = "hostname"))]
-                let hostname = DEFAULT_MESSAGE_ID_DOMAIN.to_string();
-
-                self.header(header::MessageId::from(
-                    // https://tools.ietf.org/html/rfc5322#section-3.6.4
-                    format!("<{}@{}>", make_message_id(), hostname),
-                ))
-            }
-        }
-    }
-
-    /// Set [User-Agent
-    /// header](https://tools.ietf.org/html/draft-melnikov-email-user-agent-004)
-    pub fn user_agent(self, id: String) -> Self {
-        self.header(header::UserAgent::from(id))
-    }
-
-    /// Force specific envelope (by default it is derived from headers)
-    pub fn envelope(mut self, envelope: Envelope) -> Self {
-        self.envelope = Some(envelope);
-        self
-    }
-
-    // TODO: High-level methods for attachments and embedded files
-
-    /// Create message from body
-    fn build(self, body: MessageBody) -> Result<Message, EmailError> {
-        // Check for missing required headers
-        // https://tools.ietf.org/html/rfc5322#section-3.6
-
-        // Insert Date if missing
-        let res = if self.headers.get::<header::Date>().is_none() {
-            self.date_now()
-        } else {
-            self
-        };
-
-        // Fail is missing correct originator (Sender or From)
-        match res.headers.get::<header::From>() {
-            Some(header::From(f)) => {
-                let from: Vec<Mailbox> = f.into();
-                if from.len() > 1 && res.headers.get::<header::Sender>().is_none() {
-                    return Err(EmailError::TooManyFrom);
-                }
-            }
-            None => {
-                return Err(EmailError::MissingFrom);
-            }
-        }
-
-        let envelope = match res.envelope {
-            Some(e) => e,
-            None => Envelope::try_from(&res.headers)?,
-        };
-        Ok(Message {
-            headers: res.headers,
-            body,
-            envelope,
-        })
-    }
-
-    /// Create [`Message`] using a [`Vec<u8>`], [`String`], or [`Body`] body
-    ///
-    /// Automatically gets encoded with `7bit`, `quoted-printable` or `base64`
-    /// `Content-Transfer-Encoding`, based on the most efficient and valid encoding
-    /// for `body`.
-    pub fn body<T: IntoBody>(mut self, body: T) -> Result<Message, EmailError> {
-        let maybe_encoding = self.headers.get::<ContentTransferEncoding>();
-        let body = body.into_body(maybe_encoding);
-
-        self.headers.set(body.encoding());
-        self.build(MessageBody::Raw(body.into_vec()))
-    }
-
-    /// Create message using mime body ([`MultiPart`][self::MultiPart])
-    pub fn multipart(self, part: MultiPart) -> Result<Message, EmailError> {
-        self.mime_1_0().build(MessageBody::Mime(Part::Multi(part)))
-    }
-
-    /// Create message using mime body ([`SinglePart`][self::SinglePart])
-    pub fn singlepart(self, part: SinglePart) -> Result<Message, EmailError> {
-        self.mime_1_0().build(MessageBody::Mime(Part::Single(part)))
-    }
-}
-
-/// Email message which can be formatted
-#[cfg_attr(docsrs, doc(cfg(feature = "builder")))]
-#[derive(Clone, Debug)]
-pub struct Message {
-    headers: Headers,
-    body: MessageBody,
-    envelope: Envelope,
-}
-
-#[derive(Clone, Debug)]
-enum MessageBody {
-    Mime(Part),
-    Raw(Vec<u8>),
-}
-
-impl Message {
-    /// Create a new message builder without headers
-    pub fn builder() -> MessageBuilder {
-        MessageBuilder::new()
-    }
-
-    /// Get the headers from the Message
-    pub fn headers(&self) -> &Headers {
-        &self.headers
-    }
-
-    /// Get `Message` envelope
-    pub fn envelope(&self) -> &Envelope {
-        &self.envelope
-    }
-
-    /// Get message content formatted for SMTP
-    pub fn formatted(&self) -> Vec<u8> {
-        let mut out = Vec::new();
-        self.format(&mut out);
-        out
-    }
-}
-
-impl EmailFormat for Message {
-    fn format(&self, out: &mut Vec<u8>) {
-        write!(out, "{}", self.headers)
-            .expect("A Write implementation panicked while formatting headers");
-
-        match &self.body {
-            MessageBody::Mime(p) => p.format(out),
-            MessageBody::Raw(r) => {
-                out.extend_from_slice(b"\r\n");
-                out.extend_from_slice(&r)
-            }
-        }
-    }
-}
-
-impl Default for MessageBuilder {
-    fn default() -> Self {
-        MessageBuilder::new()
-    }
-}
-
-/// Create a random message id.
-/// (Not cryptographically random)
-fn make_message_id() -> String {
-    iter::repeat_with(fastrand::alphanumeric).take(36).collect()
-}
-
-#[cfg(test)]
-mod test {
-    use std::time::{Duration, SystemTime};
-
-    use super::{header, mailbox::Mailbox, make_message_id, Message, MultiPart, SinglePart};
-
-    #[test]
-    fn email_missing_originator() {
-        assert!(Message::builder()
-            .body(String::from("Happy new year!"))
-            .is_err());
-    }
-
-    #[test]
-    fn email_miminal_message() {
-        assert!(Message::builder()
-            .from("NoBody <nobody@domain.tld>".parse().unwrap())
-            .to("NoBody <nobody@domain.tld>".parse().unwrap())
-            .body(String::from("Happy new year!"))
-            .is_ok());
-    }
-
-    #[test]
-    fn email_missing_sender() {
-        assert!(Message::builder()
-            .from("NoBody <nobody@domain.tld>".parse().unwrap())
-            .from("AnyBody <anybody@domain.tld>".parse().unwrap())
-            .body(String::from("Happy new year!"))
-            .is_err());
-    }
-
-    #[test]
-    fn email_message() {
-        // Tue, 15 Nov 1994 08:12:31 GMT
-        let date = SystemTime::UNIX_EPOCH + Duration::from_secs(784887151);
-
-        let email = Message::builder()
-            .date(date)
-            .header(header::From(
-                vec![Mailbox::new(
-                    Some("Каи".into()),
-                    "kayo@example.com".parse().unwrap(),
-                )]
-                .into(),
-            ))
-            .header(header::To(
-                vec!["Pony O.P. <pony@domain.tld>".parse().unwrap()].into(),
-            ))
-            .header(header::Subject::from(String::from("яңа ел белән!")))
-            .body(String::from("Happy new year!"))
-            .unwrap();
-
-        assert_eq!(
-            String::from_utf8(email.formatted()).unwrap(),
-            concat!(
-                "Date: Tue, 15 Nov 1994 08:12:31 -0000\r\n",
-                "From: =?utf-8?b?0JrQsNC4?= <kayo@example.com>\r\n",
-                "To: Pony O.P. <pony@domain.tld>\r\n",
-                "Subject: =?utf-8?b?0Y/So9CwINC10Lsg0LHQtdC705nQvSE=?=\r\n",
-                "Content-Transfer-Encoding: 7bit\r\n",
-                "\r\n",
-                "Happy new year!"
-            )
-        );
-    }
-
-    #[test]
-    fn email_with_png() {
-        // Tue, 15 Nov 1994 08:12:31 GMT
-        let date = SystemTime::UNIX_EPOCH + Duration::from_secs(784887151);
-        let img = std::fs::read("./docs/lettre.png").unwrap();
-        let m = Message::builder()
-            .date(date)
-            .from("NoBody <nobody@domain.tld>".parse().unwrap())
-            .reply_to("Yuin <yuin@domain.tld>".parse().unwrap())
-            .to("Hei <hei@domain.tld>".parse().unwrap())
-            .subject("Happy new year")
-            .multipart(
-                MultiPart::related()
-                    .singlepart(
-                        SinglePart::builder()
-                            .header(header::ContentType::TEXT_HTML)
-                            .body(String::from(
-                                "<p><b>Hello</b>, <i>world</i>! <img src=cid:123></p>",
-                            )),
-                    )
-                    .singlepart(
-                        SinglePart::builder()
-                            .header(header::ContentType::parse("image/png").unwrap())
-                            .header(header::ContentDisposition::inline())
-                            .header(header::ContentId::from(String::from("<123>")))
-                            .body(img),
-                    ),
-            )
-            .unwrap();
-
-        let output = String::from_utf8(m.formatted()).unwrap();
-        let file_expected = std::fs::read("./testdata/email_with_png.eml").unwrap();
-        let expected = String::from_utf8(file_expected).unwrap();
-
-        for (i, line) in output.lines().zip(expected.lines()).enumerate() {
-            if i == 7 || i == 9 || i == 14 || i == 233 {
-                continue;
-            }
-
-            assert_eq!(line.0, line.1)
-        }
-    }
-
-    #[test]
-    fn test_make_message_id() {
-        let mut ids = std::collections::HashSet::with_capacity(10);
-        for _ in 0..1000 {
-            ids.insert(make_message_id());
-        }
-
-        // Ensure there are no duplicates
-        assert_eq!(1000, ids.len());
-
-        // Ensure correct length
-        for id in ids {
-            assert_eq!(36, id.len());
-        }
-    }
-}

src/transport/file/error.rs

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

src/transport/file/mod.rs

@@ -1,318 +0,0 @@
-//! The file transport writes the emails to the given directory. The name of the file will be
-//! `message_id.eml`.
-//! It can be useful for testing purposes, or if you want to keep track of sent messages.
-//!
-//! ## Sync example
-//!
-//! ```rust
-//! # use std::error::Error;
-//! #
-//! # #[cfg(all(feature = "file-transport", feature = "builder"))]
-//! # fn main() -> Result<(), Box<dyn Error>> {
-//! use lettre::{FileTransport, Message, Transport};
-//! use std::env::temp_dir;
-//!
-//! // Write to the local temp directory
-//! let sender = FileTransport::new(temp_dir());
-//! let email = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
-//!     .subject("Happy new year")
-//!     .body(String::from("Be happy!"))?;
-//!
-//! let result = sender.send(&email);
-//! assert!(result.is_ok());
-//! # Ok(())
-//! # }
-//!
-//! # #[cfg(not(all(feature = "file-transport", feature = "builder")))]
-//! # fn main() {}
-//! ```
-//!
-//! ## Sync example with envelope
-//!
-//! It is possible to also write the envelope content in a separate JSON file
-//! by using the `with_envelope` builder. The JSON file will be written in the
-//! target directory with same name and a `json` extension.
-//!
-//! ```rust
-//! # use std::error::Error;
-//! #
-//! # #[cfg(all(feature = "file-transport-envelope", feature = "builder"))]
-//! # fn main() -> Result<(), Box<dyn Error>> {
-//! use lettre::{FileTransport, Message, Transport};
-//! use std::env::temp_dir;
-//!
-//! // Write to the local temp directory
-//! let sender = FileTransport::with_envelope(temp_dir());
-//! let email = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
-//!     .subject("Happy new year")
-//!     .body(String::from("Be happy!"))?;
-//!
-//! let result = sender.send(&email);
-//! assert!(result.is_ok());
-//! # Ok(())
-//! # }
-//!
-//! # #[cfg(not(all(feature = "file-transport-envelope", feature = "builder")))]
-//! # fn main() {}
-//! ```
-//!
-//! ## Async tokio 1.x
-//!
-//! ```rust,no_run
-//! # use std::error::Error;
-//! #
-//! # #[cfg(all(feature = "tokio1", feature = "file-transport", feature = "builder"))]
-//! # async fn run() -> Result<(), Box<dyn Error>> {
-//! use std::env::temp_dir;
-//! use lettre::{AsyncTransport, Tokio1Executor, Message, AsyncFileTransport};
-//!
-//! // Write to the local temp directory
-//! let sender = AsyncFileTransport::<Tokio1Executor>::new(temp_dir());
-//! let email = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
-//!     .subject("Happy new year")
-//!     .body(String::from("Be happy!"))?;
-//!
-//! let result = sender.send(email).await;
-//! assert!(result.is_ok());
-//! # Ok(())
-//! # }
-//! ```
-//!
-//! ## Async async-std 1.x
-//!
-//! ```rust,no_run
-//! # use std::error::Error;
-//! #
-//! # #[cfg(all(feature = "async-std1", feature = "file-transport", feature = "builder"))]
-//! # async fn run() -> Result<(), Box<dyn Error>> {
-//! use std::env::temp_dir;
-//! use lettre::{AsyncTransport, AsyncStd1Executor, Message, AsyncFileTransport};
-//!
-//! // Write to the local temp directory
-//! let sender = AsyncFileTransport::<AsyncStd1Executor>::new(temp_dir());
-//! let email = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
-//!     .subject("Happy new year")
-//!     .body(String::from("Be happy!"))?;
-//!
-//! let result = sender.send(email).await;
-//! assert!(result.is_ok());
-//! # Ok(())
-//! # }
-//! ```
-//!
-//! ---
-//!
-//! Example email content result
-//!
-//! ```eml
-//! From: NoBody <nobody@domain.tld>
-//! Reply-To: Yuin <yuin@domain.tld>
-//! To: Hei <hei@domain.tld>
-//! Subject: Happy new year
-//! Date: Tue, 18 Aug 2020 22:50:17 GMT
-//!
-//! Be happy!
-//! ```
-//!
-//! Example envelope result
-//!
-//! ```json
-//! {"forward_path":["hei@domain.tld"],"reverse_path":"nobody@domain.tld"}
-//! ```
-
-pub use self::error::Error;
-use crate::{address::Envelope, Transport};
-#[cfg(any(feature = "async-std1", feature = "tokio1"))]
-use crate::{AsyncTransport, Executor};
-#[cfg(any(feature = "async-std1", feature = "tokio1"))]
-use async_trait::async_trait;
-#[cfg(any(feature = "async-std1", feature = "tokio1"))]
-use std::marker::PhantomData;
-use std::{
-    path::{Path, PathBuf},
-    str,
-};
-use uuid::Uuid;
-
-mod error;
-
-type Id = String;
-
-/// Writes the content and the envelope information to a file
-#[derive(Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-#[cfg_attr(docsrs, doc(cfg(feature = "file-transport")))]
-pub struct FileTransport {
-    path: PathBuf,
-    #[cfg(feature = "file-transport-envelope")]
-    save_envelope: bool,
-}
-
-/// Asynchronously writes the content and the envelope information to a file
-#[derive(Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-#[cfg_attr(docsrs, doc(cfg(any(feature = "tokio1", feature = "async-std1"))))]
-#[cfg(any(feature = "async-std1", feature = "tokio1"))]
-pub struct AsyncFileTransport<E: Executor> {
-    inner: FileTransport,
-    marker_: PhantomData<E>,
-}
-
-impl FileTransport {
-    /// Creates a new transport to the given directory
-    ///
-    /// Writes the email content in eml format.
-    pub fn new<P: AsRef<Path>>(path: P) -> FileTransport {
-        FileTransport {
-            path: PathBuf::from(path.as_ref()),
-            #[cfg(feature = "file-transport-envelope")]
-            save_envelope: false,
-        }
-    }
-
-    /// Creates a new transport to the given directory
-    ///
-    /// Writes the email content in eml format and the envelope
-    /// in json format.
-    #[cfg(feature = "file-transport-envelope")]
-    pub fn with_envelope<P: AsRef<Path>>(path: P) -> FileTransport {
-        FileTransport {
-            path: PathBuf::from(path.as_ref()),
-            #[cfg(feature = "file-transport-envelope")]
-            save_envelope: true,
-        }
-    }
-
-    /// Read a message that was written using the file transport.
-    ///
-    /// Reads the envelope and the raw message content.
-    #[cfg(feature = "file-transport-envelope")]
-    pub fn read(&self, email_id: &str) -> Result<(Envelope, Vec<u8>), Error> {
-        use std::fs;
-
-        let eml_file = self.path.join(format!("{}.eml", email_id));
-        let eml = fs::read(eml_file).map_err(error::io)?;
-
-        let json_file = self.path.join(format!("{}.json", email_id));
-        let json = fs::read(&json_file).map_err(error::io)?;
-        let envelope = serde_json::from_slice(&json).map_err(error::envelope)?;
-
-        Ok((envelope, eml))
-    }
-
-    fn path(&self, email_id: &Uuid, extension: &str) -> PathBuf {
-        self.path.join(format!("{}.{}", email_id, extension))
-    }
-}
-
-#[cfg(any(feature = "async-std1", feature = "tokio1"))]
-impl<E> AsyncFileTransport<E>
-where
-    E: Executor,
-{
-    /// Creates a new transport to the given directory
-    ///
-    /// Writes the email content in eml format.
-    pub fn new<P: AsRef<Path>>(path: P) -> Self {
-        Self {
-            inner: FileTransport::new(path),
-            marker_: PhantomData,
-        }
-    }
-
-    /// Creates a new transport to the given directory
-    ///
-    /// Writes the email content in eml format and the envelope
-    /// in json format.
-    #[cfg(feature = "file-transport-envelope")]
-    pub fn with_envelope<P: AsRef<Path>>(path: P) -> Self {
-        Self {
-            inner: FileTransport::with_envelope(path),
-            marker_: PhantomData,
-        }
-    }
-
-    /// Read a message that was written using the file transport.
-    ///
-    /// Reads the envelope and the raw message content.
-    #[cfg(feature = "file-transport-envelope")]
-    pub async fn read(&self, email_id: &str) -> Result<(Envelope, Vec<u8>), Error> {
-        let eml_file = self.inner.path.join(format!("{}.eml", email_id));
-        let eml = E::fs_read(&eml_file).await.map_err(error::io)?;
-
-        let json_file = self.inner.path.join(format!("{}.json", email_id));
-        let json = E::fs_read(&json_file).await.map_err(error::io)?;
-        let envelope = serde_json::from_slice(&json).map_err(error::envelope)?;
-
-        Ok((envelope, eml))
-    }
-}
-
-impl Transport for FileTransport {
-    type Ok = Id;
-    type Error = Error;
-
-    fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
-        use std::fs;
-
-        let email_id = Uuid::new_v4();
-
-        let file = self.path(&email_id, "eml");
-        fs::write(file, email).map_err(error::io)?;
-
-        #[cfg(feature = "file-transport-envelope")]
-        {
-            if self.save_envelope {
-                let file = self.path(&email_id, "json");
-                let buf = serde_json::to_string(&envelope).map_err(error::envelope)?;
-                fs::write(file, buf).map_err(error::io)?;
-            }
-        }
-        // use envelope anyway
-        let _ = envelope;
-
-        Ok(email_id.to_string())
-    }
-}
-
-#[cfg(any(feature = "async-std1", feature = "tokio1"))]
-#[async_trait]
-impl<E> AsyncTransport for AsyncFileTransport<E>
-where
-    E: Executor,
-{
-    type Ok = Id;
-    type Error = Error;
-
-    async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
-        let email_id = Uuid::new_v4();
-
-        let file = self.inner.path(&email_id, "eml");
-        E::fs_write(&file, email).await.map_err(error::io)?;
-
-        #[cfg(feature = "file-transport-envelope")]
-        {
-            if self.inner.save_envelope {
-                let file = self.inner.path(&email_id, "json");
-                let buf = serde_json::to_vec(&envelope).map_err(error::envelope)?;
-                E::fs_write(&file, &buf).await.map_err(error::io)?;
-            }
-        }
-        // use envelope anyway
-        let _ = envelope;
-
-        Ok(email_id.to_string())
-    }
-}

src/transport/mod.rs

@@ -1,159 +0,0 @@
-//! ## Transports for sending emails
-//!
-//! This module contains `Transport`s for sending emails. A `Transport` implements a high-level API
-//! for sending emails. It automatically manages the underlying resources and doesn't require any
-//! specific knowledge of email protocols in order to be used.
-//!
-//! ### Getting started
-//!
-//! Sending emails from your programs requires using an email relay, as client libraries are not
-//! designed to handle email delivery by themselves. Depending on your infrastructure, your relay
-//! could be:
-//!
-//! * a service from your Cloud or hosting provider
-//! * an email server ([MTA] for Mail Transfer Agent, like Postfix or Exchange), running either
-//! locally on your servers or accessible over the network
-//! * a dedicated external service, like Mailchimp, Mailgun, etc.
-//!
-//! In most cases, the best option is to:
-//!
-//! * Use the [`SMTP`] transport, with the [`relay`] builder (or one of its async counterparts)
-//!   with your server's hostname. They provide modern and secure defaults.
-//! * Use the [`credentials`] method of the builder to pass your credentials.
-//!
-//! These should be enough to safely cover most use cases.
-//!
-//! ### Available transports
-//!
-//! The following transports are available:
-//!
-//! | Module       | Protocol | Sync API              | Async API                  | Description                                             |
-//! | ------------ | -------- | --------------------- | -------------------------- | ------------------------------------------------------- |
-//! | [`smtp`]     | SMTP     | [`SmtpTransport`]     | [`AsyncSmtpTransport`]     | Uses the SMTP protocol to send emails to a relay server |
-//! | [`sendmail`] | Sendmail | [`SendmailTransport`] | [`AsyncSendmailTransport`] | Uses the `sendmail` command to send emails              |
-//! | [`file`]     | File     | [`FileTransport`]     | [`AsyncFileTransport`]     | Saves the email as an `.eml` file                       |
-//! | [`stub`]     | Debug    | [`StubTransport`]     | [`StubTransport`]          | Drops the email - Useful for debugging                  |
-//!
-//! ## Building an email
-//!
-//! Emails can either be built though [`Message`], which is a typed API for constructing emails
-//! (find out more about it by going over the [`message`][crate::message] module),
-//! or via external means.
-//!
-//! [`Message`]s can be sent via [`Transport::send`] or [`AsyncTransport::send`], while messages
-//! built without lettre's [`message`][crate::message] APIs can be sent via [`Transport::send_raw`]
-//! or [`AsyncTransport::send_raw`].
-//!
-//! ## Brief example
-//!
-//! This example shows how to build an email and send it via an SMTP relay server.
-//! It is in no way a complete example, but it shows how to get started with lettre.
-//! More examples can be found by looking at the specific modules, linked in the _Module_ column
-//! of the [table above](#transports-for-sending-emails).
-//!
-//! ```rust,no_run
-//! # use std::error::Error;
-//! #
-//! # #[cfg(all(feature = "builder", feature = "smtp-transport"))]
-//! # fn main() -> Result<(), Box<dyn Error>> {
-//! use lettre::transport::smtp::authentication::Credentials;
-//! use lettre::{Message, SmtpTransport, Transport};
-//!
-//! let email = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
-//!     .subject("Happy new year")
-//!     .body(String::from("Be happy!"))?;
-//!
-//! let creds = Credentials::new("smtp_username".to_string(), "smtp_password".to_string());
-//!
-//! // Open a remote connection to the SMTP relay server
-//! let mailer = SmtpTransport::relay("smtp.gmail.com")?
-//!     .credentials(creds)
-//!     .build();
-//!
-//! // Send the email
-//! match mailer.send(&email) {
-//!     Ok(_) => println!("Email sent successfully!"),
-//!     Err(e) => panic!("Could not send email: {:?}", e),
-//! }
-//! # Ok(())
-//! # }
-//! # #[cfg(not(all(feature = "builder", feature = "smtp-transport")))]
-//! # fn main() {}
-//! ```
-//!
-//! [MTA]: https://en.wikipedia.org/wiki/Message_transfer_agent
-//! [`SMTP`]: crate::transport::smtp
-//! [`relay`]: crate::SmtpTransport::relay
-//! [`starttls_relay`]: crate::SmtpTransport::starttls_relay
-//! [`credentials`]: crate::transport::smtp::SmtpTransportBuilder::credentials
-//! [`Message`]: crate::Message
-//! [`file`]: self::file
-//! [`SmtpTransport`]: crate::SmtpTransport
-//! [`AsyncSmtpTransport`]: crate::AsyncSmtpTransport
-//! [`SendmailTransport`]: crate::SendmailTransport
-//! [`AsyncSendmailTransport`]: crate::AsyncSendmailTransport
-//! [`FileTransport`]: crate::FileTransport
-//! [`AsyncFileTransport`]: crate::AsyncFileTransport
-//! [`StubTransport`]: crate::transport::stub::StubTransport
-
-#[cfg(any(feature = "async-std1", feature = "tokio1"))]
-use async_trait::async_trait;
-
-use crate::Envelope;
-#[cfg(feature = "builder")]
-use crate::Message;
-
-#[cfg(feature = "file-transport")]
-#[cfg_attr(docsrs, doc(cfg(feature = "file-transport")))]
-pub mod file;
-#[cfg(feature = "sendmail-transport")]
-#[cfg_attr(docsrs, doc(cfg(feature = "sendmail-transport")))]
-pub mod sendmail;
-#[cfg(feature = "smtp-transport")]
-#[cfg_attr(docsrs, doc(cfg(feature = "smtp-transport")))]
-pub mod smtp;
-pub mod stub;
-
-/// Blocking Transport method for emails
-pub trait Transport {
-    /// Response produced by the Transport
-    type Ok;
-    /// Error produced by the Transport
-    type Error;
-
-    /// Sends the email
-    #[cfg(feature = "builder")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "builder")))]
-    fn send(&self, message: &Message) -> Result<Self::Ok, Self::Error> {
-        let raw = message.formatted();
-        self.send_raw(message.envelope(), &raw)
-    }
-
-    fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error>;
-}
-
-/// Async Transport method for emails
-#[cfg(any(feature = "tokio1", feature = "async-std1"))]
-#[cfg_attr(docsrs, doc(cfg(any(feature = "tokio1", feature = "async-std1"))))]
-#[async_trait]
-pub trait AsyncTransport {
-    /// Response produced by the Transport
-    type Ok;
-    /// Error produced by the Transport
-    type Error;
-
-    /// Sends the email
-    #[cfg(feature = "builder")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "builder")))]
-    // TODO take &Message
-    async fn send(&self, message: Message) -> Result<Self::Ok, Self::Error> {
-        let raw = message.formatted();
-        let envelope = message.envelope();
-        self.send_raw(&envelope, &raw).await
-    }
-
-    async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error>;
-}

src/transport/sendmail/error.rs

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

src/transport/sendmail/mod.rs

@@ -1,307 +0,0 @@
-//! The sendmail transport sends the email using the local `sendmail` command.
-//!
-//! ## Sync example
-//!
-//! ```rust
-//! # use std::error::Error;
-//! #
-//! # #[cfg(all(feature = "sendmail-transport", feature = "builder"))]
-//! # fn main() -> Result<(), Box<dyn Error>> {
-//! use lettre::{Message, SendmailTransport, Transport};
-//!
-//! let email = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
-//!     .subject("Happy new year")
-//!     .body(String::from("Be happy!"))?;
-//!
-//! let sender = SendmailTransport::new();
-//! let result = sender.send(&email);
-//! assert!(result.is_ok());
-//! # Ok(())
-//! # }
-//!
-//! # #[cfg(not(all(feature = "sendmail-transport", feature = "builder")))]
-//! # fn main() {}
-//! ```
-//!
-//! ## Async tokio 1.x example
-//!
-//! ```rust,no_run
-//! # use std::error::Error;
-//! #
-//! # #[cfg(all(feature = "tokio1", feature = "sendmail-transport", feature = "builder"))]
-//! # async fn run() -> Result<(), Box<dyn Error>> {
-//! use lettre::{Message, AsyncTransport, Tokio1Executor, AsyncSendmailTransport, SendmailTransport};
-//!
-//! let email = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
-//!     .subject("Happy new year")
-//!     .body(String::from("Be happy!"))?;
-//!
-//! let sender = AsyncSendmailTransport::<Tokio1Executor>::new();
-//! let result = sender.send(email).await;
-//! assert!(result.is_ok());
-//! # Ok(())
-//! # }
-//! ```
-//!
-//! ## Async async-std 1.x example
-//!
-//!```rust,no_run
-//! # use std::error::Error;
-//! #
-//! # #[cfg(all(feature = "async-std1", feature = "sendmail-transport", feature = "builder"))]
-//! # async fn run() -> Result<(), Box<dyn Error>> {
-//! use lettre::{Message, AsyncTransport, AsyncStd1Executor, AsyncSendmailTransport};
-//!
-//! let email = Message::builder()
-//!     .from("NoBody <nobody@domain.tld>".parse()?)
-//!     .reply_to("Yuin <yuin@domain.tld>".parse()?)
-//!     .to("Hei <hei@domain.tld>".parse()?)
-//!     .subject("Happy new year")
-//!     .body(String::from("Be happy!"))?;
-//!
-//! let sender = AsyncSendmailTransport::<AsyncStd1Executor>::new();
-//! let result = sender.send(email).await;
-//! assert!(result.is_ok());
-//! # Ok(())
-//! # }
-//! ```
-
-pub use self::error::Error;
-#[cfg(feature = "async-std1")]
-use crate::AsyncStd1Executor;
-#[cfg(feature = "tokio1")]
-use crate::Tokio1Executor;
-use crate::{address::Envelope, Transport};
-#[cfg(any(feature = "async-std1", feature = "tokio1"))]
-use crate::{AsyncTransport, Executor};
-#[cfg(any(feature = "async-std1", feature = "tokio1"))]
-use async_trait::async_trait;
-#[cfg(any(feature = "async-std1", feature = "tokio1"))]
-use std::marker::PhantomData;
-use std::{
-    ffi::OsString,
-    io::Write,
-    process::{Command, Stdio},
-};
-
-mod error;
-
-const DEFAULT_SENDMAIL: &str = "/usr/sbin/sendmail";
-
-/// Sends emails using the `sendmail` command
-#[derive(Debug, Clone)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-#[cfg_attr(docsrs, doc(cfg(feature = "sendmail-transport")))]
-pub struct SendmailTransport {
-    command: OsString,
-}
-
-/// Asynchronously sends emails using the `sendmail` command
-#[derive(Debug, Clone)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-#[cfg(any(feature = "async-std1", feature = "tokio1"))]
-#[cfg_attr(docsrs, doc(cfg(any(feature = "tokio1", feature = "async-std1"))))]
-pub struct AsyncSendmailTransport<E: Executor> {
-    inner: SendmailTransport,
-    marker_: PhantomData<E>,
-}
-
-impl SendmailTransport {
-    /// Creates a new transport with the default `/usr/sbin/sendmail` command
-    pub fn new() -> SendmailTransport {
-        SendmailTransport {
-            command: DEFAULT_SENDMAIL.into(),
-        }
-    }
-
-    /// Creates a new transport to the given sendmail command
-    pub fn new_with_command<S: Into<OsString>>(command: S) -> SendmailTransport {
-        SendmailTransport {
-            command: command.into(),
-        }
-    }
-
-    fn command(&self, envelope: &Envelope) -> Command {
-        let mut c = Command::new(&self.command);
-        c.arg("-i");
-        if let Some(from) = envelope.from() {
-            c.arg("-f").arg(from);
-        }
-        c.arg("--")
-            .args(envelope.to())
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped());
-        c
-    }
-}
-
-#[cfg(any(feature = "async-std1", feature = "tokio1"))]
-impl<E> AsyncSendmailTransport<E>
-where
-    E: Executor,
-{
-    /// Creates a new transport with the default `/usr/sbin/sendmail` command
-    pub fn new() -> Self {
-        Self {
-            inner: SendmailTransport::new(),
-            marker_: PhantomData,
-        }
-    }
-
-    /// Creates a new transport to the given sendmail command
-    pub fn new_with_command<S: Into<OsString>>(command: S) -> Self {
-        Self {
-            inner: SendmailTransport::new_with_command(command),
-            marker_: PhantomData,
-        }
-    }
-
-    #[cfg(feature = "tokio1")]
-    fn tokio1_command(&self, envelope: &Envelope) -> tokio1_crate::process::Command {
-        use tokio1_crate::process::Command;
-
-        let mut c = Command::new(&self.inner.command);
-        c.kill_on_drop(true);
-        c.arg("-i");
-        if let Some(from) = envelope.from() {
-            c.arg("-f").arg(from);
-        }
-        c.arg("--")
-            .args(envelope.to())
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped());
-        c
-    }
-
-    #[cfg(feature = "async-std1")]
-    fn async_std_command(&self, envelope: &Envelope) -> async_std::process::Command {
-        use async_std::process::Command;
-
-        let mut c = Command::new(&self.inner.command);
-        // TODO: figure out why enabling this kills it earlier
-        // c.kill_on_drop(true);
-        c.arg("-i");
-        if let Some(from) = envelope.from() {
-            c.arg("-f").arg(from);
-        }
-        c.arg("--")
-            .args(envelope.to())
-            .stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped());
-        c
-    }
-}
-
-impl Default for SendmailTransport {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[cfg(any(feature = "async-std1", feature = "tokio1"))]
-impl<E> Default for AsyncSendmailTransport<E>
-where
-    E: Executor,
-{
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Transport for SendmailTransport {
-    type Ok = ();
-    type Error = Error;
-
-    fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
-        // Spawn the sendmail command
-        let mut process = self.command(envelope).spawn().map_err(error::client)?;
-
-        process
-            .stdin
-            .as_mut()
-            .unwrap()
-            .write_all(email)
-            .map_err(error::client)?;
-        let output = process.wait_with_output().map_err(error::client)?;
-
-        if output.status.success() {
-            Ok(())
-        } else {
-            let stderr = String::from_utf8(output.stderr).map_err(error::response)?;
-            Err(error::client(stderr))
-        }
-    }
-}
-
-#[cfg(feature = "async-std1")]
-#[async_trait]
-impl AsyncTransport for AsyncSendmailTransport<AsyncStd1Executor> {
-    type Ok = ();
-    type Error = Error;
-
-    async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
-        use async_std::io::prelude::WriteExt;
-
-        let mut command = self.async_std_command(envelope);
-
-        // Spawn the sendmail command
-        let mut process = command.spawn().map_err(error::client)?;
-
-        process
-            .stdin
-            .as_mut()
-            .unwrap()
-            .write_all(&email)
-            .await
-            .map_err(error::client)?;
-        let output = process.output().await.map_err(error::client)?;
-
-        if output.status.success() {
-            Ok(())
-        } else {
-            let stderr = String::from_utf8(output.stderr).map_err(error::response)?;
-            Err(error::client(stderr))
-        }
-    }
-}
-
-#[cfg(feature = "tokio1")]
-#[async_trait]
-impl AsyncTransport for AsyncSendmailTransport<Tokio1Executor> {
-    type Ok = ();
-    type Error = Error;
-
-    async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
-        use tokio1_crate::io::AsyncWriteExt;
-
-        let mut command = self.tokio1_command(envelope);
-
-        // Spawn the sendmail command
-        let mut process = command.spawn().map_err(error::client)?;
-
-        process
-            .stdin
-            .as_mut()
-            .unwrap()
-            .write_all(&email)
-            .await
-            .map_err(error::client)?;
-        let output = process.wait_with_output().await.map_err(error::client)?;
-
-        if output.status.success() {
-            Ok(())
-        } else {
-            let stderr = String::from_utf8(output.stderr).map_err(error::response)?;
-            Err(error::client(stderr))
-        }
-    }
-}

src/transport/smtp/async_transport.rs

@@ -1,291 +0,0 @@
-use std::{
-    fmt::{self, Debug},
-    marker::PhantomData,
-};
-
-use async_trait::async_trait;
-
-use super::{
-    client::AsyncSmtpConnection, ClientId, Credentials, Error, Mechanism, Response, SmtpInfo,
-};
-#[cfg(feature = "async-std1")]
-use crate::AsyncStd1Executor;
-#[cfg(any(feature = "tokio1", feature = "async-std1"))]
-use crate::AsyncTransport;
-#[cfg(feature = "tokio1")]
-use crate::Tokio1Executor;
-use crate::{Envelope, Executor};
-
-/// Asynchronously sends emails using the SMTP protocol
-#[cfg_attr(docsrs, doc(cfg(any(feature = "tokio1", feature = "async-std1"))))]
-pub struct AsyncSmtpTransport<E> {
-    // TODO: pool
-    inner: AsyncSmtpClient<E>,
-}
-
-#[cfg(feature = "tokio1")]
-#[async_trait]
-impl AsyncTransport for AsyncSmtpTransport<Tokio1Executor> {
-    type Ok = Response;
-    type Error = Error;
-
-    /// Sends an email
-    async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
-        let mut conn = self.inner.connection().await?;
-
-        let result = conn.send(envelope, email).await?;
-
-        conn.quit().await?;
-
-        Ok(result)
-    }
-}
-
-#[cfg(feature = "async-std1")]
-#[async_trait]
-impl AsyncTransport for AsyncSmtpTransport<AsyncStd1Executor> {
-    type Ok = Response;
-    type Error = Error;
-
-    /// Sends an email
-    async fn send_raw(&self, envelope: &Envelope, email: &[u8]) -> Result<Self::Ok, Self::Error> {
-        let mut conn = self.inner.connection().await?;
-
-        let result = conn.send(envelope, email).await?;
-
-        conn.quit().await?;
-
-        Ok(result)
-    }
-}
-
-impl<E> AsyncSmtpTransport<E>
-where
-    E: Executor,
-{
-    /// Simple and secure transport, using TLS connections to communicate with the SMTP server
-    ///
-    /// The right option for most SMTP servers.
-    ///
-    /// Creates an encrypted transport over submissions port, using the provided domain
-    /// to validate TLS certificates.
-    #[cfg(any(
-        feature = "tokio1-native-tls",
-        feature = "tokio1-rustls-tls",
-        feature = "async-std1-native-tls",
-        feature = "async-std1-rustls-tls"
-    ))]
-    #[cfg_attr(
-        docsrs,
-        doc(cfg(any(
-            feature = "tokio1-native-tls",
-            feature = "tokio1-rustls-tls",
-            feature = "async-std1-rustls-tls"
-        )))
-    )]
-    pub fn relay(relay: &str) -> Result<AsyncSmtpTransportBuilder, Error> {
-        use super::{Tls, TlsParameters, SUBMISSIONS_PORT};
-
-        let tls_parameters = TlsParameters::new(relay.into())?;
-
-        Ok(Self::builder_dangerous(relay)
-            .port(SUBMISSIONS_PORT)
-            .tls(Tls::Wrapper(tls_parameters)))
-    }
-
-    /// Simple an secure transport, using STARTTLS to obtain encrypted connections
-    ///
-    /// Alternative to [`AsyncSmtpTransport::relay`](#method.relay), for SMTP servers
-    /// that don't take SMTPS connections.
-    ///
-    /// Creates an encrypted transport over submissions port, by first connecting using
-    /// an unencrypted connection and then upgrading it with STARTTLS. The provided
-    /// domain is used to validate TLS certificates.
-    ///
-    /// 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 = "tokio1-native-tls",
-        feature = "tokio1-rustls-tls",
-        feature = "async-std1-native-tls",
-        feature = "async-std1-rustls-tls"
-    ))]
-    #[cfg_attr(
-        docsrs,
-        doc(cfg(any(
-            feature = "tokio1-native-tls",
-            feature = "tokio1-rustls-tls",
-            feature = "async-std1-rustls-tls"
-        )))
-    )]
-    pub fn starttls_relay(relay: &str) -> Result<AsyncSmtpTransportBuilder, Error> {
-        use super::{Tls, TlsParameters, SUBMISSION_PORT};
-
-        let tls_parameters = TlsParameters::new(relay.into())?;
-
-        Ok(Self::builder_dangerous(relay)
-            .port(SUBMISSION_PORT)
-            .tls(Tls::Required(tls_parameters)))
-    }
-
-    /// Creates a new local SMTP client to port 25
-    ///
-    /// Shortcut for local unencrypted relay (typical local email daemon that will handle relaying)
-    pub fn unencrypted_localhost() -> AsyncSmtpTransport<E> {
-        Self::builder_dangerous("localhost").build()
-    }
-
-    /// Creates a new SMTP client
-    ///
-    /// Defaults are:
-    ///
-    /// * No authentication
-    /// * No TLS
-    /// * Port 25
-    ///
-    /// Consider using [`AsyncSmtpTransport::relay`](#method.relay) or
-    /// [`AsyncSmtpTransport::starttls_relay`](#method.starttls_relay) instead,
-    /// if possible.
-    pub fn builder_dangerous<T: Into<String>>(server: T) -> AsyncSmtpTransportBuilder {
-        let new = SmtpInfo {
-            server: server.into(),
-            ..Default::default()
-        };
-        AsyncSmtpTransportBuilder { info: new }
-    }
-}
-
-impl<E> Debug for AsyncSmtpTransport<E> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut builder = f.debug_struct("AsyncSmtpTransport");
-        builder.field("inner", &self.inner);
-        builder.finish()
-    }
-}
-
-impl<E> Clone for AsyncSmtpTransport<E>
-where
-    E: Executor,
-{
-    fn clone(&self) -> Self {
-        Self {
-            inner: self.inner.clone(),
-        }
-    }
-}
-
-/// Contains client configuration.
-/// Instances of this struct can be created using functions of [`AsyncSmtpTransport`].
-#[derive(Debug, Clone)]
-#[cfg_attr(docsrs, doc(cfg(any(feature = "tokio1", feature = "async-std1"))))]
-pub struct AsyncSmtpTransportBuilder {
-    info: SmtpInfo,
-}
-
-/// Builder for the SMTP `AsyncSmtpTransport`
-impl AsyncSmtpTransportBuilder {
-    /// Set the name used during EHLO
-    pub fn hello_name(mut self, name: ClientId) -> Self {
-        self.info.hello_name = name;
-        self
-    }
-
-    /// Set the authentication mechanism to use
-    pub fn credentials(mut self, credentials: Credentials) -> Self {
-        self.info.credentials = Some(credentials);
-        self
-    }
-
-    /// Set the authentication mechanism to use
-    pub fn authentication(mut self, mechanisms: Vec<Mechanism>) -> Self {
-        self.info.authentication = mechanisms;
-        self
-    }
-
-    /// Set the port to use
-    pub fn port(mut self, port: u16) -> Self {
-        self.info.port = port;
-        self
-    }
-
-    /// Set the TLS settings to use
-    #[cfg(any(
-        feature = "tokio1-native-tls",
-        feature = "tokio1-rustls-tls",
-        feature = "async-std1-native-tls",
-        feature = "async-std1-rustls-tls"
-    ))]
-    #[cfg_attr(
-        docsrs,
-        doc(cfg(any(
-            feature = "tokio1-native-tls",
-            feature = "tokio1-rustls-tls",
-            feature = "async-std1-rustls-tls"
-        )))
-    )]
-    pub fn tls(mut self, tls: super::Tls) -> Self {
-        self.info.tls = tls;
-        self
-    }
-
-    /// Build the transport
-    pub fn build<E>(self) -> AsyncSmtpTransport<E>
-    where
-        E: Executor,
-    {
-        let client = AsyncSmtpClient {
-            info: self.info,
-            marker_: PhantomData,
-        };
-        AsyncSmtpTransport { inner: client }
-    }
-}
-
-/// Build client
-pub struct AsyncSmtpClient<E> {
-    info: SmtpInfo,
-    marker_: PhantomData<E>,
-}
-
-impl<E> AsyncSmtpClient<E>
-where
-    E: Executor,
-{
-    /// Creates a new connection directly usable to send emails
-    ///
-    /// Handles encryption and authentication
-    pub async fn connection(&self) -> Result<AsyncSmtpConnection, Error> {
-        let mut conn = E::connect(
-            &self.info.server,
-            self.info.port,
-            &self.info.hello_name,
-            &self.info.tls,
-        )
-        .await?;
-
-        if let Some(credentials) = &self.info.credentials {
-            conn.auth(&self.info.authentication, &credentials).await?;
-        }
-        Ok(conn)
-    }
-}
-
-impl<E> Debug for AsyncSmtpClient<E> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut builder = f.debug_struct("AsyncSmtpClient");
-        builder.field("info", &self.info);
-        builder.finish()
-    }
-}
-
-impl<E> AsyncSmtpClient<E>
-where
-    E: Executor,
-{
-    fn clone(&self) -> Self {
-        Self {
-            info: self.info.clone(),
-            marker_: PhantomData,
-        }
-    }
-}

src/transport/smtp/authentication.rs

@@ -1,177 +0,0 @@
-//! Provides limited SASL authentication mechanisms
-
-use crate::transport::smtp::error::{self, Error};
-use std::fmt::{self, Debug, Display, Formatter};
-
-/// Accepted authentication mechanisms
-/// Trying LOGIN last as it is deprecated.
-pub const DEFAULT_MECHANISMS: &[Mechanism] = &[Mechanism::Plain, Mechanism::Login];
-
-/// Contains user credentials
-#[derive(PartialEq, Eq, Clone, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct Credentials {
-    authentication_identity: String,
-    secret: String,
-}
-
-impl Credentials {
-    /// Create a `Credentials` struct from username and password
-    pub fn new(username: String, password: String) -> Credentials {
-        Credentials {
-            authentication_identity: username,
-            secret: password,
-        }
-    }
-}
-
-impl<S, T> From<(S, T)> for Credentials
-where
-    S: Into<String>,
-    T: Into<String>,
-{
-    fn from((username, password): (S, T)) -> Self {
-        Credentials::new(username.into(), password.into())
-    }
-}
-
-impl Debug for Credentials {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Credentials").finish()
-    }
-}
-
-/// Represents authentication mechanisms
-#[derive(PartialEq, Eq, Copy, Clone, Hash, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub enum Mechanism {
-    /// PLAIN authentication mechanism, defined in
-    /// [RFC 4616](https://tools.ietf.org/html/rfc4616)
-    Plain,
-    /// LOGIN authentication mechanism
-    /// Obsolete but needed for some providers (like office365)
-    ///
-    /// Defined in [draft-murchison-sasl-login-00](https://www.ietf.org/archive/id/draft-murchison-sasl-login-00.txt).
-    Login,
-    /// Non-standard XOAUTH2 mechanism, defined in
-    /// [xoauth2-protocol](https://developers.google.com/gmail/imap/xoauth2-protocol)
-    Xoauth2,
-}
-
-impl Display for Mechanism {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        f.write_str(match *self {
-            Mechanism::Plain => "PLAIN",
-            Mechanism::Login => "LOGIN",
-            Mechanism::Xoauth2 => "XOAUTH2",
-        })
-    }
-}
-
-impl Mechanism {
-    /// Does the mechanism supports initial response
-    pub fn supports_initial_response(self) -> bool {
-        match self {
-            Mechanism::Plain | Mechanism::Xoauth2 => true,
-            Mechanism::Login => false,
-        }
-    }
-
-    /// Returns the string to send to the server, using the provided username, password and
-    /// challenge in some cases
-    pub fn response(
-        self,
-        credentials: &Credentials,
-        challenge: Option<&str>,
-    ) -> Result<String, Error> {
-        match self {
-            Mechanism::Plain => match challenge {
-                Some(_) => Err(error::client("This mechanism does not expect a challenge")),
-                None => Ok(format!(
-                    "\u{0}{}\u{0}{}",
-                    credentials.authentication_identity, credentials.secret
-                )),
-            },
-            Mechanism::Login => {
-                let decoded_challenge = challenge
-                    .ok_or_else(|| error::client("This mechanism does expect a challenge"))?;
-
-                if vec!["User Name", "Username:", "Username"].contains(&decoded_challenge) {
-                    return Ok(credentials.authentication_identity.to_string());
-                }
-
-                if vec!["Password", "Password:"].contains(&decoded_challenge) {
-                    return Ok(credentials.secret.to_string());
-                }
-
-                Err(error::client("Unrecognized challenge"))
-            }
-            Mechanism::Xoauth2 => match challenge {
-                Some(_) => Err(error::client("This mechanism does not expect a challenge")),
-                None => Ok(format!(
-                    "user={}\x01auth=Bearer {}\x01\x01",
-                    credentials.authentication_identity, credentials.secret
-                )),
-            },
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::{Credentials, Mechanism};
-
-    #[test]
-    fn test_plain() {
-        let mechanism = Mechanism::Plain;
-
-        let credentials = Credentials::new("username".to_string(), "password".to_string());
-
-        assert_eq!(
-            mechanism.response(&credentials, None).unwrap(),
-            "\u{0}username\u{0}password"
-        );
-        assert!(mechanism.response(&credentials, Some("test")).is_err());
-    }
-
-    #[test]
-    fn test_login() {
-        let mechanism = Mechanism::Login;
-
-        let credentials = Credentials::new("alice".to_string(), "wonderland".to_string());
-
-        assert_eq!(
-            mechanism.response(&credentials, Some("Username")).unwrap(),
-            "alice"
-        );
-        assert_eq!(
-            mechanism.response(&credentials, Some("Password")).unwrap(),
-            "wonderland"
-        );
-        assert!(mechanism.response(&credentials, None).is_err());
-    }
-
-    #[test]
-    fn test_xoauth2() {
-        let mechanism = Mechanism::Xoauth2;
-
-        let credentials = Credentials::new(
-            "username".to_string(),
-            "vF9dft4qmTc2Nvb3RlckBhdHRhdmlzdGEuY29tCg==".to_string(),
-        );
-
-        assert_eq!(
-            mechanism.response(&credentials, None).unwrap(),
-            "user=username\x01auth=Bearer vF9dft4qmTc2Nvb3RlckBhdHRhdmlzdGEuY29tCg==\x01\x01"
-        );
-        assert!(mechanism.response(&credentials, Some("test")).is_err());
-    }
-
-    #[test]
-    fn test_from_user_pass_for_credentials() {
-        assert_eq!(
-            Credentials::new("alice".to_string(), "wonderland".to_string()),
-            Credentials::from(("alice", "wonderland"))
-        );
-    }
-}

src/transport/smtp/client/async_connection.rs

@@ -1,316 +0,0 @@
-use super::{AsyncNetworkStream, ClientCodec, TlsParameters};
-use crate::{
-    transport::smtp::{
-        authentication::{Credentials, Mechanism},
-        commands::*,
-        error,
-        error::Error,
-        extension::{ClientId, Extension, MailBodyParameter, MailParameter, ServerInfo},
-        response::{parse_response, Response},
-    },
-    Envelope,
-};
-use futures_util::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
-use std::fmt::Display;
-
-#[cfg(feature = "tracing")]
-use super::escape_crlf;
-
-macro_rules! try_smtp (
-    ($err: expr, $client: ident) => ({
-        match $err {
-            Ok(val) => val,
-            Err(err) => {
-                $client.abort().await;
-                return Err(From::from(err))
-            },
-        }
-    })
-);
-
-/// Structure that implements the SMTP client
-pub struct AsyncSmtpConnection {
-    /// TCP stream between client and server
-    /// Value is None before connection
-    stream: BufReader<AsyncNetworkStream>,
-    /// Panic state
-    panic: bool,
-    /// Information about the server
-    server_info: ServerInfo,
-}
-
-impl AsyncSmtpConnection {
-    pub fn server_info(&self) -> &ServerInfo {
-        &self.server_info
-    }
-
-    /// Connects to the configured server
-    ///
-    /// Sends EHLO and parses server information
-    #[cfg(feature = "tokio1")]
-    pub async fn connect_tokio1(
-        hostname: &str,
-        port: u16,
-        hello_name: &ClientId,
-        tls_parameters: Option<TlsParameters>,
-    ) -> Result<AsyncSmtpConnection, Error> {
-        let stream = AsyncNetworkStream::connect_tokio1(hostname, port, tls_parameters).await?;
-        Self::connect_impl(stream, hello_name).await
-    }
-
-    /// Connects to the configured server
-    ///
-    /// Sends EHLO and parses server information
-    #[cfg(feature = "async-std1")]
-    pub async fn connect_asyncstd1(
-        hostname: &str,
-        port: u16,
-        hello_name: &ClientId,
-        tls_parameters: Option<TlsParameters>,
-    ) -> Result<AsyncSmtpConnection, Error> {
-        let stream = AsyncNetworkStream::connect_asyncstd1(hostname, port, tls_parameters).await?;
-        Self::connect_impl(stream, hello_name).await
-    }
-
-    async fn connect_impl(
-        stream: AsyncNetworkStream,
-        hello_name: &ClientId,
-    ) -> Result<AsyncSmtpConnection, Error> {
-        let stream = BufReader::new(stream);
-        let mut conn = AsyncSmtpConnection {
-            stream,
-            panic: false,
-            server_info: ServerInfo::default(),
-        };
-        // TODO log
-        let _response = conn.read_response().await?;
-
-        conn.ehlo(hello_name).await?;
-
-        // Print server information
-        #[cfg(feature = "tracing")]
-        tracing::debug!("server {}", conn.server_info);
-        Ok(conn)
-    }
-
-    pub async fn send(&mut self, envelope: &Envelope, email: &[u8]) -> Result<Response, Error> {
-        // Mail
-        let mut mail_options = vec![];
-
-        // Internationalization handling
-        //
-        // * 8BITMIME: https://tools.ietf.org/html/rfc6152
-        // * SMTPUTF8: https://tools.ietf.org/html/rfc653
-
-        // Check for non-ascii addresses and use the SMTPUTF8 option if any.
-        if envelope.has_non_ascii_addresses() {
-            if !self.server_info().supports_feature(Extension::SmtpUtfEight) {
-                // don't try to send non-ascii addresses (per RFC)
-                return Err(error::client(
-                    "Envelope contains non-ascii chars but server does not support SMTPUTF8",
-                ));
-            }
-            mail_options.push(MailParameter::SmtpUtfEight);
-        }
-
-        // Check for non-ascii content in message
-        if !email.is_ascii() {
-            if !self.server_info().supports_feature(Extension::EightBitMime) {
-                return Err(error::client(
-                    "Message contains non-ascii chars but server does not support 8BITMIME",
-                ));
-            }
-            mail_options.push(MailParameter::Body(MailBodyParameter::EightBitMime));
-        }
-
-        try_smtp!(
-            self.command(Mail::new(envelope.from().cloned(), mail_options))
-                .await,
-            self
-        );
-
-        // Recipient
-        for to_address in envelope.to() {
-            try_smtp!(
-                self.command(Rcpt::new(to_address.clone(), vec![])).await,
-                self
-            );
-        }
-
-        // Data
-        try_smtp!(self.command(Data).await, self);
-
-        // Message content
-        let result = try_smtp!(self.message(email).await, self);
-        Ok(result)
-    }
-
-    pub fn has_broken(&self) -> bool {
-        self.panic
-    }
-
-    pub fn can_starttls(&self) -> bool {
-        !self.is_encrypted() && self.server_info.supports_feature(Extension::StartTls)
-    }
-
-    #[allow(unused_variables)]
-    pub async fn starttls(
-        &mut self,
-        tls_parameters: TlsParameters,
-        hello_name: &ClientId,
-    ) -> Result<(), Error> {
-        if self.server_info.supports_feature(Extension::StartTls) {
-            try_smtp!(self.command(Starttls).await, self);
-            try_smtp!(
-                self.stream.get_mut().upgrade_tls(tls_parameters).await,
-                self
-            );
-            #[cfg(feature = "tracing")]
-            tracing::debug!("connection encrypted");
-            // Send EHLO again
-            try_smtp!(self.ehlo(hello_name).await, self);
-            Ok(())
-        } else {
-            Err(error::client("STARTTLS is not supported on this server"))
-        }
-    }
-
-    /// Send EHLO and update server info
-    async fn ehlo(&mut self, hello_name: &ClientId) -> Result<(), Error> {
-        let ehlo_response = try_smtp!(self.command(Ehlo::new(hello_name.clone())).await, self);
-        self.server_info = try_smtp!(ServerInfo::from_response(&ehlo_response), self);
-        Ok(())
-    }
-
-    pub async fn quit(&mut self) -> Result<Response, Error> {
-        Ok(try_smtp!(self.command(Quit).await, self))
-    }
-
-    pub async fn abort(&mut self) {
-        // Only try to quit if we are not already broken
-        if !self.panic {
-            self.panic = true;
-            let _ = self.command(Quit).await;
-        }
-    }
-
-    /// Sets the underlying stream
-    pub fn set_stream(&mut self, stream: AsyncNetworkStream) {
-        self.stream = BufReader::new(stream);
-    }
-
-    /// Tells if the underlying stream is currently encrypted
-    pub fn is_encrypted(&self) -> bool {
-        self.stream.get_ref().is_encrypted()
-    }
-
-    /// Checks if the server is connected using the NOOP SMTP command
-    pub async fn test_connected(&mut self) -> bool {
-        self.command(Noop).await.is_ok()
-    }
-
-    /// Sends an AUTH command with the given mechanism, and handles challenge if needed
-    pub async fn auth(
-        &mut self,
-        mechanisms: &[Mechanism],
-        credentials: &Credentials,
-    ) -> Result<Response, Error> {
-        let mechanism = self
-            .server_info
-            .get_auth_mechanism(mechanisms)
-            .ok_or_else(|| error::client("No compatible authentication mechanism was found"))?;
-
-        // Limit challenges to avoid blocking
-        let mut challenges: u8 = 10;
-        let mut response = self
-            .command(Auth::new(mechanism, credentials.clone(), None)?)
-            .await?;
-
-        while challenges > 0 && response.has_code(334) {
-            challenges -= 1;
-            response = try_smtp!(
-                self.command(Auth::new_from_response(
-                    mechanism,
-                    credentials.clone(),
-                    &response,
-                )?)
-                .await,
-                self
-            );
-        }
-
-        if challenges == 0 {
-            Err(error::response("Unexpected number of challenges"))
-        } else {
-            Ok(response)
-        }
-    }
-
-    /// Sends the message content
-    pub async fn message(&mut self, message: &[u8]) -> Result<Response, Error> {
-        let mut out_buf: Vec<u8> = vec![];
-        let mut codec = ClientCodec::new();
-        codec.encode(message, &mut out_buf);
-        self.write(out_buf.as_slice()).await?;
-        self.write(b"\r\n.\r\n").await?;
-        self.read_response().await
-    }
-
-    /// Sends an SMTP command
-    pub async fn command<C: Display>(&mut self, command: C) -> Result<Response, Error> {
-        self.write(command.to_string().as_bytes()).await?;
-        self.read_response().await
-    }
-
-    /// Writes a string to the server
-    async fn write(&mut self, string: &[u8]) -> Result<(), Error> {
-        self.stream
-            .get_mut()
-            .write_all(string)
-            .await
-            .map_err(error::network)?;
-        self.stream
-            .get_mut()
-            .flush()
-            .await
-            .map_err(error::network)?;
-
-        #[cfg(feature = "tracing")]
-        tracing::debug!("Wrote: {}", escape_crlf(&String::from_utf8_lossy(string)));
-        Ok(())
-    }
-
-    /// Gets the SMTP response
-    pub async fn read_response(&mut self) -> Result<Response, Error> {
-        let mut buffer = String::with_capacity(100);
-
-        while self
-            .stream
-            .read_line(&mut buffer)
-            .await
-            .map_err(error::network)?
-            > 0
-        {
-            #[cfg(feature = "tracing")]
-            tracing::debug!("<< {}", escape_crlf(&buffer));
-            match parse_response(&buffer) {
-                Ok((_remaining, response)) => {
-                    return if response.is_positive() {
-                        Ok(response)
-                    } else {
-                        Err(error::code(response.code))
-                    }
-                }
-                Err(nom::Err::Failure(e)) => {
-                    return Err(error::response(e.to_string()));
-                }
-                Err(nom::Err::Incomplete(_)) => { /* read more */ }
-                Err(nom::Err::Error(e)) => {
-                    return Err(error::response(e.to_string()));
-                }
-            }
-        }
-
-        Err(error::response("incomplete response"))
-    }
-}

src/transport/smtp/client/async_net.rs

@@ -1,438 +0,0 @@
-use std::{
-    mem,
-    net::SocketAddr,
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use futures_io::{
-    AsyncRead as FuturesAsyncRead, AsyncWrite as FuturesAsyncWrite, Error as IoError, ErrorKind,
-    Result as IoResult,
-};
-#[cfg(feature = "tokio1")]
-use tokio1_crate::io::{AsyncRead as _, AsyncWrite as _, ReadBuf as Tokio1ReadBuf};
-
-#[cfg(feature = "async-std1")]
-use async_std::net::TcpStream as AsyncStd1TcpStream;
-#[cfg(feature = "tokio1")]
-use tokio1_crate::net::TcpStream as Tokio1TcpStream;
-
-#[cfg(feature = "async-std1-native-tls")]
-use async_native_tls::TlsStream as AsyncStd1TlsStream;
-#[cfg(feature = "tokio1-native-tls")]
-use tokio1_native_tls_crate::TlsStream as Tokio1TlsStream;
-
-#[cfg(feature = "async-std1-rustls-tls")]
-use async_rustls::client::TlsStream as AsyncStd1RustlsTlsStream;
-#[cfg(feature = "tokio1-rustls-tls")]
-use tokio1_rustls::client::TlsStream as Tokio1RustlsTlsStream;
-
-#[cfg(any(
-    feature = "tokio1-native-tls",
-    feature = "tokio1-rustls-tls",
-    feature = "async-std1-native-tls",
-    feature = "async-std1-rustls-tls"
-))]
-use super::InnerTlsParameters;
-use super::TlsParameters;
-use crate::transport::smtp::{error, Error};
-
-/// A network stream
-pub struct AsyncNetworkStream {
-    inner: InnerAsyncNetworkStream,
-}
-
-/// Represents the different types of underlying network streams
-// usually only one TLS backend at a time is going to be enabled,
-// so clippy::large_enum_variant doesn't make sense here
-#[allow(clippy::large_enum_variant)]
-#[allow(dead_code)]
-enum InnerAsyncNetworkStream {
-    /// Plain Tokio 1.x TCP stream
-    #[cfg(feature = "tokio1")]
-    Tokio1Tcp(Tokio1TcpStream),
-    /// Encrypted Tokio 1.x TCP stream
-    #[cfg(feature = "tokio1-native-tls")]
-    Tokio1NativeTls(Tokio1TlsStream<Tokio1TcpStream>),
-    /// Encrypted Tokio 1.x TCP stream
-    #[cfg(feature = "tokio1-rustls-tls")]
-    Tokio1RustlsTls(Tokio1RustlsTlsStream<Tokio1TcpStream>),
-    /// Plain Tokio 1.x TCP stream
-    #[cfg(feature = "async-std1")]
-    AsyncStd1Tcp(AsyncStd1TcpStream),
-    /// Encrypted Tokio 1.x TCP stream
-    #[cfg(feature = "async-std1-native-tls")]
-    AsyncStd1NativeTls(AsyncStd1TlsStream<AsyncStd1TcpStream>),
-    /// Encrypted Tokio 1.x TCP stream
-    #[cfg(feature = "async-std1-rustls-tls")]
-    AsyncStd1RustlsTls(AsyncStd1RustlsTlsStream<AsyncStd1TcpStream>),
-    /// Can't be built
-    None,
-}
-
-impl AsyncNetworkStream {
-    fn new(inner: InnerAsyncNetworkStream) -> Self {
-        if let InnerAsyncNetworkStream::None = inner {
-            debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
-        }
-
-        AsyncNetworkStream { inner }
-    }
-
-    /// Returns peer's address
-    pub fn peer_addr(&self) -> IoResult<SocketAddr> {
-        match self.inner {
-            #[cfg(feature = "tokio1")]
-            InnerAsyncNetworkStream::Tokio1Tcp(ref s) => s.peer_addr(),
-            #[cfg(feature = "tokio1-native-tls")]
-            InnerAsyncNetworkStream::Tokio1NativeTls(ref s) => {
-                s.get_ref().get_ref().get_ref().peer_addr()
-            }
-            #[cfg(feature = "tokio1-rustls-tls")]
-            InnerAsyncNetworkStream::Tokio1RustlsTls(ref s) => s.get_ref().0.peer_addr(),
-            #[cfg(feature = "async-std1")]
-            InnerAsyncNetworkStream::AsyncStd1Tcp(ref s) => s.peer_addr(),
-            #[cfg(feature = "async-std1-native-tls")]
-            InnerAsyncNetworkStream::AsyncStd1NativeTls(ref s) => s.get_ref().peer_addr(),
-            #[cfg(feature = "async-std1-rustls-tls")]
-            InnerAsyncNetworkStream::AsyncStd1RustlsTls(ref s) => s.get_ref().0.peer_addr(),
-            InnerAsyncNetworkStream::None => {
-                debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
-                Err(IoError::new(
-                    ErrorKind::Other,
-                    "InnerAsyncNetworkStream::None must never be built",
-                ))
-            }
-        }
-    }
-
-    #[cfg(feature = "tokio1")]
-    pub async fn connect_tokio1(
-        hostname: &str,
-        port: u16,
-        tls_parameters: Option<TlsParameters>,
-    ) -> Result<AsyncNetworkStream, Error> {
-        let tcp_stream = Tokio1TcpStream::connect((hostname, port))
-            .await
-            .map_err(error::connection)?;
-
-        let mut stream = AsyncNetworkStream::new(InnerAsyncNetworkStream::Tokio1Tcp(tcp_stream));
-        if let Some(tls_parameters) = tls_parameters {
-            stream.upgrade_tls(tls_parameters).await?;
-        }
-        Ok(stream)
-    }
-
-    #[cfg(feature = "async-std1")]
-    pub async fn connect_asyncstd1(
-        hostname: &str,
-        port: u16,
-        tls_parameters: Option<TlsParameters>,
-    ) -> Result<AsyncNetworkStream, Error> {
-        let tcp_stream = AsyncStd1TcpStream::connect((hostname, port))
-            .await
-            .map_err(error::connection)?;
-
-        let mut stream = AsyncNetworkStream::new(InnerAsyncNetworkStream::AsyncStd1Tcp(tcp_stream));
-        if let Some(tls_parameters) = tls_parameters {
-            stream.upgrade_tls(tls_parameters).await?;
-        }
-        Ok(stream)
-    }
-
-    pub async fn upgrade_tls(&mut self, tls_parameters: TlsParameters) -> Result<(), Error> {
-        match &self.inner {
-            #[cfg(all(
-                feature = "tokio1",
-                not(any(feature = "tokio1-native-tls", feature = "tokio1-rustls-tls"))
-            ))]
-            InnerAsyncNetworkStream::Tokio1Tcp(_) => {
-                let _ = tls_parameters;
-                panic!("Trying to upgrade an AsyncNetworkStream without having enabled either the tokio1-native-tls or the tokio1-rustls-tls feature");
-            }
-
-            #[cfg(any(feature = "tokio1-native-tls", feature = "tokio1-rustls-tls"))]
-            InnerAsyncNetworkStream::Tokio1Tcp(_) => {
-                // get owned TcpStream
-                let tcp_stream = mem::replace(&mut self.inner, InnerAsyncNetworkStream::None);
-                let tcp_stream = match tcp_stream {
-                    InnerAsyncNetworkStream::Tokio1Tcp(tcp_stream) => tcp_stream,
-                    _ => unreachable!(),
-                };
-
-                self.inner = Self::upgrade_tokio1_tls(tcp_stream, tls_parameters)
-                    .await
-                    .map_err(error::connection)?;
-                Ok(())
-            }
-            #[cfg(all(
-                feature = "async-std1",
-                not(any(feature = "async-std1-native-tls", feature = "async-std1-rustls-tls"))
-            ))]
-            InnerAsyncNetworkStream::AsyncStd1Tcp(_) => {
-                let _ = tls_parameters;
-                panic!("Trying to upgrade an AsyncNetworkStream without having enabled either the async-std1-native-tls or the async-std1-rustls-tls feature");
-            }
-
-            #[cfg(any(feature = "async-std1-native-tls", feature = "async-std1-rustls-tls"))]
-            InnerAsyncNetworkStream::AsyncStd1Tcp(_) => {
-                // get owned TcpStream
-                let tcp_stream = mem::replace(&mut self.inner, InnerAsyncNetworkStream::None);
-                let tcp_stream = match tcp_stream {
-                    InnerAsyncNetworkStream::AsyncStd1Tcp(tcp_stream) => tcp_stream,
-                    _ => unreachable!(),
-                };
-
-                self.inner = Self::upgrade_asyncstd1_tls(tcp_stream, tls_parameters)
-                    .await
-                    .map_err(error::connection)?;
-                Ok(())
-            }
-            _ => Ok(()),
-        }
-    }
-
-    #[allow(unused_variables)]
-    #[cfg(any(feature = "tokio1-native-tls", feature = "tokio1-rustls-tls"))]
-    async fn upgrade_tokio1_tls(
-        tcp_stream: Tokio1TcpStream,
-        mut tls_parameters: TlsParameters,
-    ) -> Result<InnerAsyncNetworkStream, Error> {
-        let domain = mem::take(&mut tls_parameters.domain);
-
-        match tls_parameters.connector {
-            #[cfg(feature = "native-tls")]
-            InnerTlsParameters::NativeTls(connector) => {
-                #[cfg(not(feature = "tokio1-native-tls"))]
-                panic!("built without the tokio1-native-tls feature");
-
-                #[cfg(feature = "tokio1-native-tls")]
-                return {
-                    use tokio1_native_tls_crate::TlsConnector;
-
-                    let connector = TlsConnector::from(connector);
-                    let stream = connector
-                        .connect(&domain, tcp_stream)
-                        .await
-                        .map_err(error::connection)?;
-                    Ok(InnerAsyncNetworkStream::Tokio1NativeTls(stream))
-                };
-            }
-            #[cfg(feature = "rustls-tls")]
-            InnerTlsParameters::RustlsTls(config) => {
-                #[cfg(not(feature = "tokio1-rustls-tls"))]
-                panic!("built without the tokio1-rustls-tls feature");
-
-                #[cfg(feature = "tokio1-rustls-tls")]
-                return {
-                    use tokio1_rustls::{webpki::DNSNameRef, TlsConnector};
-
-                    let domain =
-                        DNSNameRef::try_from_ascii_str(&domain).map_err(error::connection)?;
-
-                    let connector = TlsConnector::from(config);
-                    let stream = connector
-                        .connect(domain, tcp_stream)
-                        .await
-                        .map_err(error::connection)?;
-                    Ok(InnerAsyncNetworkStream::Tokio1RustlsTls(stream))
-                };
-            }
-        }
-    }
-
-    #[allow(unused_variables)]
-    #[cfg(any(feature = "async-std1-native-tls", feature = "async-std1-rustls-tls"))]
-    async fn upgrade_asyncstd1_tls(
-        tcp_stream: AsyncStd1TcpStream,
-        mut tls_parameters: TlsParameters,
-    ) -> Result<InnerAsyncNetworkStream, Error> {
-        let domain = mem::take(&mut tls_parameters.domain);
-
-        match tls_parameters.connector {
-            #[cfg(feature = "native-tls")]
-            InnerTlsParameters::NativeTls(connector) => {
-                panic!("native-tls isn't supported with async-std yet. See https://github.com/lettre/lettre/pull/531#issuecomment-757893531");
-
-                /*
-                #[cfg(not(feature = "async-std1-native-tls"))]
-                panic!("built without the async-std1-native-tls feature");
-
-                #[cfg(feature = "async-std1-native-tls")]
-                return {
-                    use async_native_tls::TlsConnector;
-
-                    // TODO: fix
-                    let connector: TlsConnector = todo!();
-                    // let connector = TlsConnector::from(connector);
-                    let stream = connector.connect(&domain, tcp_stream).await?;
-                    Ok(InnerAsyncNetworkStream::AsyncStd1NativeTls(stream))
-                };
-                */
-            }
-            #[cfg(feature = "rustls-tls")]
-            InnerTlsParameters::RustlsTls(config) => {
-                #[cfg(not(feature = "async-std1-rustls-tls"))]
-                panic!("built without the async-std1-rustls-tls feature");
-
-                #[cfg(feature = "async-std1-rustls-tls")]
-                return {
-                    use async_rustls::{webpki::DNSNameRef, TlsConnector};
-
-                    let domain =
-                        DNSNameRef::try_from_ascii_str(&domain).map_err(error::connection)?;
-
-                    let connector = TlsConnector::from(config);
-                    let stream = connector
-                        .connect(domain, tcp_stream)
-                        .await
-                        .map_err(error::connection)?;
-                    Ok(InnerAsyncNetworkStream::AsyncStd1RustlsTls(stream))
-                };
-            }
-        }
-    }
-
-    pub fn is_encrypted(&self) -> bool {
-        match self.inner {
-            #[cfg(feature = "tokio1")]
-            InnerAsyncNetworkStream::Tokio1Tcp(_) => false,
-            #[cfg(feature = "tokio1-native-tls")]
-            InnerAsyncNetworkStream::Tokio1NativeTls(_) => true,
-            #[cfg(feature = "tokio1-rustls-tls")]
-            InnerAsyncNetworkStream::Tokio1RustlsTls(_) => true,
-            #[cfg(feature = "async-std1")]
-            InnerAsyncNetworkStream::AsyncStd1Tcp(_) => false,
-            #[cfg(feature = "async-std1-native-tls")]
-            InnerAsyncNetworkStream::AsyncStd1NativeTls(_) => true,
-            #[cfg(feature = "async-std1-rustls-tls")]
-            InnerAsyncNetworkStream::AsyncStd1RustlsTls(_) => true,
-            InnerAsyncNetworkStream::None => false,
-        }
-    }
-}
-
-impl FuturesAsyncRead for AsyncNetworkStream {
-    fn poll_read(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut [u8],
-    ) -> Poll<IoResult<usize>> {
-        match self.inner {
-            #[cfg(feature = "tokio1")]
-            InnerAsyncNetworkStream::Tokio1Tcp(ref mut s) => {
-                let mut b = Tokio1ReadBuf::new(buf);
-                match Pin::new(s).poll_read(cx, &mut b) {
-                    Poll::Ready(Ok(())) => Poll::Ready(Ok(b.filled().len())),
-                    Poll::Ready(Err(err)) => Poll::Ready(Err(err)),
-                    Poll::Pending => Poll::Pending,
-                }
-            }
-            #[cfg(feature = "tokio1-native-tls")]
-            InnerAsyncNetworkStream::Tokio1NativeTls(ref mut s) => {
-                let mut b = Tokio1ReadBuf::new(buf);
-                match Pin::new(s).poll_read(cx, &mut b) {
-                    Poll::Ready(Ok(())) => Poll::Ready(Ok(b.filled().len())),
-                    Poll::Ready(Err(err)) => Poll::Ready(Err(err)),
-                    Poll::Pending => Poll::Pending,
-                }
-            }
-            #[cfg(feature = "tokio1-rustls-tls")]
-            InnerAsyncNetworkStream::Tokio1RustlsTls(ref mut s) => {
-                let mut b = Tokio1ReadBuf::new(buf);
-                match Pin::new(s).poll_read(cx, &mut b) {
-                    Poll::Ready(Ok(())) => Poll::Ready(Ok(b.filled().len())),
-                    Poll::Ready(Err(err)) => Poll::Ready(Err(err)),
-                    Poll::Pending => Poll::Pending,
-                }
-            }
-            #[cfg(feature = "async-std1")]
-            InnerAsyncNetworkStream::AsyncStd1Tcp(ref mut s) => Pin::new(s).poll_read(cx, buf),
-            #[cfg(feature = "async-std1-native-tls")]
-            InnerAsyncNetworkStream::AsyncStd1NativeTls(ref mut s) => {
-                Pin::new(s).poll_read(cx, buf)
-            }
-            #[cfg(feature = "async-std1-rustls-tls")]
-            InnerAsyncNetworkStream::AsyncStd1RustlsTls(ref mut s) => {
-                Pin::new(s).poll_read(cx, buf)
-            }
-            InnerAsyncNetworkStream::None => {
-                debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
-                Poll::Ready(Ok(0))
-            }
-        }
-    }
-}
-
-impl FuturesAsyncWrite for AsyncNetworkStream {
-    fn poll_write(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<IoResult<usize>> {
-        match self.inner {
-            #[cfg(feature = "tokio1")]
-            InnerAsyncNetworkStream::Tokio1Tcp(ref mut s) => Pin::new(s).poll_write(cx, buf),
-            #[cfg(feature = "tokio1-native-tls")]
-            InnerAsyncNetworkStream::Tokio1NativeTls(ref mut s) => Pin::new(s).poll_write(cx, buf),
-            #[cfg(feature = "tokio1-rustls-tls")]
-            InnerAsyncNetworkStream::Tokio1RustlsTls(ref mut s) => Pin::new(s).poll_write(cx, buf),
-            #[cfg(feature = "async-std1")]
-            InnerAsyncNetworkStream::AsyncStd1Tcp(ref mut s) => Pin::new(s).poll_write(cx, buf),
-            #[cfg(feature = "async-std1-native-tls")]
-            InnerAsyncNetworkStream::AsyncStd1NativeTls(ref mut s) => {
-                Pin::new(s).poll_write(cx, buf)
-            }
-            #[cfg(feature = "async-std1-rustls-tls")]
-            InnerAsyncNetworkStream::AsyncStd1RustlsTls(ref mut s) => {
-                Pin::new(s).poll_write(cx, buf)
-            }
-            InnerAsyncNetworkStream::None => {
-                debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
-                Poll::Ready(Ok(0))
-            }
-        }
-    }
-
-    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<IoResult<()>> {
-        match self.inner {
-            #[cfg(feature = "tokio1")]
-            InnerAsyncNetworkStream::Tokio1Tcp(ref mut s) => Pin::new(s).poll_flush(cx),
-            #[cfg(feature = "tokio1-native-tls")]
-            InnerAsyncNetworkStream::Tokio1NativeTls(ref mut s) => Pin::new(s).poll_flush(cx),
-            #[cfg(feature = "tokio1-rustls-tls")]
-            InnerAsyncNetworkStream::Tokio1RustlsTls(ref mut s) => Pin::new(s).poll_flush(cx),
-            #[cfg(feature = "async-std1")]
-            InnerAsyncNetworkStream::AsyncStd1Tcp(ref mut s) => Pin::new(s).poll_flush(cx),
-            #[cfg(feature = "async-std1-native-tls")]
-            InnerAsyncNetworkStream::AsyncStd1NativeTls(ref mut s) => Pin::new(s).poll_flush(cx),
-            #[cfg(feature = "async-std1-rustls-tls")]
-            InnerAsyncNetworkStream::AsyncStd1RustlsTls(ref mut s) => Pin::new(s).poll_flush(cx),
-            InnerAsyncNetworkStream::None => {
-                debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
-                Poll::Ready(Ok(()))
-            }
-        }
-    }
-
-    fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<IoResult<()>> {
-        match self.inner {
-            #[cfg(feature = "tokio1")]
-            InnerAsyncNetworkStream::Tokio1Tcp(ref mut s) => Pin::new(s).poll_shutdown(cx),
-            #[cfg(feature = "tokio1-native-tls")]
-            InnerAsyncNetworkStream::Tokio1NativeTls(ref mut s) => Pin::new(s).poll_shutdown(cx),
-            #[cfg(feature = "tokio1-rustls-tls")]
-            InnerAsyncNetworkStream::Tokio1RustlsTls(ref mut s) => Pin::new(s).poll_shutdown(cx),
-            #[cfg(feature = "async-std1")]
-            InnerAsyncNetworkStream::AsyncStd1Tcp(ref mut s) => Pin::new(s).poll_close(cx),
-            #[cfg(feature = "async-std1-native-tls")]
-            InnerAsyncNetworkStream::AsyncStd1NativeTls(ref mut s) => Pin::new(s).poll_close(cx),
-            #[cfg(feature = "async-std1-rustls-tls")]
-            InnerAsyncNetworkStream::AsyncStd1RustlsTls(ref mut s) => Pin::new(s).poll_close(cx),
-            InnerAsyncNetworkStream::None => {
-                debug_assert!(false, "InnerAsyncNetworkStream::None must never be built");
-                Poll::Ready(Ok(()))
-            }
-        }
-    }
-}

src/transport/smtp/client/connection.rs

@@ -1,294 +0,0 @@
-use std::{
-    fmt::Display,
-    io::{self, BufRead, BufReader, Write},
-    net::ToSocketAddrs,
-    time::Duration,
-};
-
-use super::{ClientCodec, NetworkStream, TlsParameters};
-use crate::{
-    address::Envelope,
-    transport::smtp::{
-        authentication::{Credentials, Mechanism},
-        commands::*,
-        error,
-        error::Error,
-        extension::{ClientId, Extension, MailBodyParameter, MailParameter, ServerInfo},
-        response::{parse_response, Response},
-    },
-};
-
-#[cfg(feature = "tracing")]
-use super::escape_crlf;
-
-macro_rules! try_smtp (
-    ($err: expr, $client: ident) => ({
-        match $err {
-            Ok(val) => val,
-            Err(err) => {
-                $client.abort();
-                return Err(From::from(err))
-            },
-        }
-    })
-);
-
-/// Structure that implements the SMTP client
-pub struct SmtpConnection {
-    /// TCP stream between client and server
-    /// Value is None before connection
-    stream: BufReader<NetworkStream>,
-    /// Panic state
-    panic: bool,
-    /// Information about the server
-    server_info: ServerInfo,
-}
-
-impl SmtpConnection {
-    pub fn server_info(&self) -> &ServerInfo {
-        &self.server_info
-    }
-
-    // FIXME add simple connect and rename this one
-
-    /// Connects to the configured server
-    ///
-    /// Sends EHLO and parses server information
-    pub fn connect<A: ToSocketAddrs>(
-        server: A,
-        timeout: Option<Duration>,
-        hello_name: &ClientId,
-        tls_parameters: Option<&TlsParameters>,
-    ) -> Result<SmtpConnection, Error> {
-        let stream = NetworkStream::connect(server, timeout, tls_parameters)?;
-        let stream = BufReader::new(stream);
-        let mut conn = SmtpConnection {
-            stream,
-            panic: false,
-            server_info: ServerInfo::default(),
-        };
-        conn.set_timeout(timeout).map_err(error::network)?;
-        // TODO log
-        let _response = conn.read_response()?;
-
-        conn.ehlo(hello_name)?;
-
-        // Print server information
-        #[cfg(feature = "tracing")]
-        tracing::debug!("server {}", conn.server_info);
-        Ok(conn)
-    }
-
-    pub fn send(&mut self, envelope: &Envelope, email: &[u8]) -> Result<Response, Error> {
-        // Mail
-        let mut mail_options = vec![];
-
-        // Internationalization handling
-        //
-        // * 8BITMIME: https://tools.ietf.org/html/rfc6152
-        // * SMTPUTF8: https://tools.ietf.org/html/rfc653
-
-        // Check for non-ascii addresses and use the SMTPUTF8 option if any.
-        if envelope.has_non_ascii_addresses() {
-            if !self.server_info().supports_feature(Extension::SmtpUtfEight) {
-                // don't try to send non-ascii addresses (per RFC)
-                return Err(error::client(
-                    "Envelope contains non-ascii chars but server does not support SMTPUTF8",
-                ));
-            }
-            mail_options.push(MailParameter::SmtpUtfEight);
-        }
-
-        // Check for non-ascii content in message
-        if !email.is_ascii() {
-            if !self.server_info().supports_feature(Extension::EightBitMime) {
-                return Err(error::client(
-                    "Message contains non-ascii chars but server does not support 8BITMIME",
-                ));
-            }
-            mail_options.push(MailParameter::Body(MailBodyParameter::EightBitMime));
-        }
-
-        try_smtp!(
-            self.command(Mail::new(envelope.from().cloned(), mail_options)),
-            self
-        );
-
-        // Recipient
-        for to_address in envelope.to() {
-            try_smtp!(self.command(Rcpt::new(to_address.clone(), vec![])), self);
-        }
-
-        // Data
-        try_smtp!(self.command(Data), self);
-
-        // Message content
-        let result = try_smtp!(self.message(email), self);
-        Ok(result)
-    }
-
-    pub fn has_broken(&self) -> bool {
-        self.panic
-    }
-
-    pub fn can_starttls(&self) -> bool {
-        !self.is_encrypted() && self.server_info.supports_feature(Extension::StartTls)
-    }
-
-    #[allow(unused_variables)]
-    pub fn starttls(
-        &mut self,
-        tls_parameters: &TlsParameters,
-        hello_name: &ClientId,
-    ) -> Result<(), Error> {
-        if self.server_info.supports_feature(Extension::StartTls) {
-            #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-            {
-                try_smtp!(self.command(Starttls), self);
-                try_smtp!(self.stream.get_mut().upgrade_tls(tls_parameters), self);
-                #[cfg(feature = "tracing")]
-                tracing::debug!("connection encrypted");
-                // Send EHLO again
-                try_smtp!(self.ehlo(hello_name), self);
-                Ok(())
-            }
-            #[cfg(not(any(feature = "native-tls", feature = "rustls-tls")))]
-            // This should never happen as `Tls` can only be created
-            // when a TLS library is enabled
-            unreachable!("TLS support required but not supported");
-        } else {
-            Err(error::client("STARTTLS is not supported on this server"))
-        }
-    }
-
-    /// Send EHLO and update server info
-    fn ehlo(&mut self, hello_name: &ClientId) -> Result<(), Error> {
-        let ehlo_response = try_smtp!(self.command(Ehlo::new(hello_name.clone())), self);
-        self.server_info = try_smtp!(ServerInfo::from_response(&ehlo_response), self);
-        Ok(())
-    }
-
-    pub fn quit(&mut self) -> Result<Response, Error> {
-        Ok(try_smtp!(self.command(Quit), self))
-    }
-
-    pub fn abort(&mut self) {
-        // Only try to quit if we are not already broken
-        if !self.panic {
-            self.panic = true;
-            let _ = self.command(Quit);
-        }
-    }
-
-    /// Sets the underlying stream
-    pub fn set_stream(&mut self, stream: NetworkStream) {
-        self.stream = BufReader::new(stream);
-    }
-
-    /// Tells if the underlying stream is currently encrypted
-    pub fn is_encrypted(&self) -> bool {
-        self.stream.get_ref().is_encrypted()
-    }
-
-    /// Set timeout
-    pub fn set_timeout(&mut self, duration: Option<Duration>) -> io::Result<()> {
-        self.stream.get_mut().set_read_timeout(duration)?;
-        self.stream.get_mut().set_write_timeout(duration)
-    }
-
-    /// Checks if the server is connected using the NOOP SMTP command
-    pub fn test_connected(&mut self) -> bool {
-        self.command(Noop).is_ok()
-    }
-
-    /// Sends an AUTH command with the given mechanism, and handles challenge if needed
-    pub fn auth(
-        &mut self,
-        mechanisms: &[Mechanism],
-        credentials: &Credentials,
-    ) -> Result<Response, Error> {
-        let mechanism = self
-            .server_info
-            .get_auth_mechanism(mechanisms)
-            .ok_or_else(|| error::client("No compatible authentication mechanism was found"))?;
-
-        // Limit challenges to avoid blocking
-        let mut challenges = 10;
-        let mut response = self.command(Auth::new(mechanism, credentials.clone(), None)?)?;
-
-        while challenges > 0 && response.has_code(334) {
-            challenges -= 1;
-            response = try_smtp!(
-                self.command(Auth::new_from_response(
-                    mechanism,
-                    credentials.clone(),
-                    &response,
-                )?),
-                self
-            );
-        }
-
-        if challenges == 0 {
-            Err(error::response("Unexpected number of challenges"))
-        } else {
-            Ok(response)
-        }
-    }
-
-    /// 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();
-        codec.encode(message, &mut out_buf);
-        self.write(out_buf.as_slice())?;
-        self.write(b"\r\n.\r\n")?;
-        self.read_response()
-    }
-
-    /// Sends an SMTP command
-    pub fn command<C: Display>(&mut self, command: C) -> Result<Response, Error> {
-        self.write(command.to_string().as_bytes())?;
-        self.read_response()
-    }
-
-    /// Writes a string to the server
-    fn write(&mut self, string: &[u8]) -> Result<(), Error> {
-        self.stream
-            .get_mut()
-            .write_all(string)
-            .map_err(error::network)?;
-        self.stream.get_mut().flush().map_err(error::network)?;
-
-        #[cfg(feature = "tracing")]
-        tracing::debug!("Wrote: {}", escape_crlf(&String::from_utf8_lossy(string)));
-        Ok(())
-    }
-
-    /// Gets the SMTP response
-    pub fn read_response(&mut self) -> Result<Response, Error> {
-        let mut buffer = String::with_capacity(100);
-
-        while self.stream.read_line(&mut buffer).map_err(error::network)? > 0 {
-            #[cfg(feature = "tracing")]
-            tracing::debug!("<< {}", escape_crlf(&buffer));
-            match parse_response(&buffer) {
-                Ok((_remaining, response)) => {
-                    return if response.is_positive() {
-                        Ok(response)
-                    } else {
-                        Err(error::code(response.code))
-                    };
-                }
-                Err(nom::Err::Failure(e)) => {
-                    return Err(error::response(e.to_string()));
-                }
-                Err(nom::Err::Incomplete(_)) => { /* read more */ }
-                Err(nom::Err::Error(e)) => {
-                    return Err(error::response(e.to_string()));
-                }
-            }
-        }
-
-        Err(error::response("incomplete response"))
-    }
-}

src/transport/smtp/client/mod.rs

@@ -1,138 +0,0 @@
-//! SMTP client
-//!
-//! `SmtpConnection` allows manually sending SMTP commands.
-//!
-//! ```rust,no_run
-//! # use std::error::Error;
-//!
-//! # #[cfg(feature = "smtp-transport")]
-//! # fn main() -> Result<(), Box<dyn Error>> {
-//! use lettre::transport::smtp::{SMTP_PORT, extension::ClientId, commands::*, client::SmtpConnection};
-//!
-//! let hello = ClientId::Domain("my_hostname".to_string());
-//! let mut client = SmtpConnection::connect(&("localhost", SMTP_PORT), None, &hello, None)?;
-//! client.command(
-//!         Mail::new(Some("user@example.com".parse()?), vec![])
-//!     )?;
-//! client.command(
-//!         Rcpt::new("user@example.org".parse()?, vec![])
-//!       )?;
-//! client.command(Data)?;
-//! client.message("Test email".as_bytes())?;
-//! client.command(Quit)?;
-//! # Ok(())
-//! # }
-//! ```
-
-#[cfg(feature = "serde")]
-use std::fmt::Debug;
-
-#[cfg(any(feature = "tokio1", feature = "async-std1"))]
-pub(crate) use self::async_connection::AsyncSmtpConnection;
-#[cfg(any(feature = "tokio1", feature = "async-std1"))]
-pub(crate) use self::async_net::AsyncNetworkStream;
-use self::net::NetworkStream;
-#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-pub(super) use self::tls::InnerTlsParameters;
-pub use self::{
-    connection::SmtpConnection,
-    tls::{Certificate, Tls, TlsParameters, TlsParametersBuilder},
-};
-
-#[cfg(any(feature = "tokio1", feature = "async-std1"))]
-mod async_connection;
-#[cfg(any(feature = "tokio1", feature = "async-std1"))]
-mod async_net;
-mod connection;
-mod net;
-mod tls;
-
-/// The codec used for transparency
-#[derive(Default, Clone, Copy, Debug)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-struct ClientCodec {
-    escape_count: u8,
-}
-
-impl ClientCodec {
-    /// Creates a new client codec
-    pub fn new() -> Self {
-        ClientCodec::default()
-    }
-
-    /// 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!(),
-                }
-                self.escape_count = 0;
-            }
-            _ => {
-                let mut start = 0;
-                for (idx, byte) in frame.iter().enumerate() {
-                    match self.escape_count {
-                        0 => self.escape_count = if *byte == b'\r' { 1 } else { 0 },
-                        1 => self.escape_count = if *byte == b'\n' { 2 } else { 0 },
-                        2 => self.escape_count = if *byte == b'.' { 3 } else { 0 },
-                        _ => unreachable!(),
-                    }
-                    if self.escape_count == 3 {
-                        self.escape_count = 0;
-                        buf.extend_from_slice(&frame[start..idx]);
-                        buf.extend_from_slice(b".");
-                        start = idx;
-                    }
-                }
-                buf.extend_from_slice(&frame[start..]);
-            }
-        }
-    }
-}
-
-/// Returns the string replacing all the CRLF with "\<CRLF\>"
-/// Used for debug displays
-#[cfg(feature = "tracing")]
-pub(super) fn escape_crlf(string: &str) -> String {
-    string.replace("\r\n", "<CRLF>")
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_codec() {
-        let mut codec = ClientCodec::new();
-        let mut buf: Vec<u8> = vec![];
-
-        codec.encode(b"test\r\n", &mut buf);
-        codec.encode(b".\r\n", &mut buf);
-        codec.encode(b"\r\ntest", &mut buf);
-        codec.encode(b"te\r\n.\r\nst", &mut buf);
-        codec.encode(b"test", &mut buf);
-        codec.encode(b"test.", &mut buf);
-        codec.encode(b"test\n", &mut buf);
-        codec.encode(b".test\n", &mut buf);
-        codec.encode(b"test", &mut buf);
-        assert_eq!(
-            String::from_utf8(buf).unwrap(),
-            "test\r\n..\r\n\r\ntestte\r\n..\r\nsttesttest.test\n.test\ntest"
-        );
-    }
-
-    #[test]
-    #[cfg(feature = "log")]
-    fn test_escape_crlf() {
-        assert_eq!(escape_crlf("\r\n"), "<CRLF>");
-        assert_eq!(escape_crlf("EHLO my_name\r\n"), "EHLO my_name<CRLF>");
-        assert_eq!(
-            escape_crlf("EHLO my_name\r\nSIZE 42\r\n"),
-            "EHLO my_name<CRLF>SIZE 42<CRLF>"
-        );
-    }
-}

src/transport/smtp/client/net.rs

@@ -1,261 +0,0 @@
-use std::{
-    io::{self, Read, Write},
-    mem,
-    net::{Ipv4Addr, Shutdown, SocketAddr, SocketAddrV4, TcpStream, ToSocketAddrs},
-    time::Duration,
-};
-
-#[cfg(feature = "native-tls")]
-use native_tls::TlsStream;
-
-#[cfg(feature = "rustls-tls")]
-use rustls::{ClientSession, StreamOwned};
-
-#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-use super::InnerTlsParameters;
-use super::TlsParameters;
-use crate::transport::smtp::{error, Error};
-
-/// A network stream
-pub struct NetworkStream {
-    inner: InnerNetworkStream,
-}
-
-/// Represents the different types of underlying network streams
-// usually only one TLS backend at a time is going to be enabled,
-// so clippy::large_enum_variant doesn't make sense here
-#[allow(clippy::large_enum_variant)]
-enum InnerNetworkStream {
-    /// Plain TCP stream
-    Tcp(TcpStream),
-    /// Encrypted TCP stream
-    #[cfg(feature = "native-tls")]
-    NativeTls(TlsStream<TcpStream>),
-    /// Encrypted TCP stream
-    #[cfg(feature = "rustls-tls")]
-    RustlsTls(StreamOwned<ClientSession, TcpStream>),
-    /// Can't be built
-    None,
-}
-
-impl NetworkStream {
-    fn new(inner: InnerNetworkStream) -> Self {
-        if let InnerNetworkStream::None = inner {
-            debug_assert!(false, "InnerNetworkStream::None must never be built");
-        }
-
-        NetworkStream { inner }
-    }
-
-    /// Returns peer's address
-    pub fn peer_addr(&self) -> io::Result<SocketAddr> {
-        match self.inner {
-            InnerNetworkStream::Tcp(ref s) => s.peer_addr(),
-            #[cfg(feature = "native-tls")]
-            InnerNetworkStream::NativeTls(ref s) => s.get_ref().peer_addr(),
-            #[cfg(feature = "rustls-tls")]
-            InnerNetworkStream::RustlsTls(ref s) => s.get_ref().peer_addr(),
-            InnerNetworkStream::None => {
-                debug_assert!(false, "InnerNetworkStream::None must never be built");
-                Ok(SocketAddr::V4(SocketAddrV4::new(
-                    Ipv4Addr::new(127, 0, 0, 1),
-                    80,
-                )))
-            }
-        }
-    }
-
-    /// Shutdowns the connection
-    pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
-        match self.inner {
-            InnerNetworkStream::Tcp(ref s) => s.shutdown(how),
-            #[cfg(feature = "native-tls")]
-            InnerNetworkStream::NativeTls(ref s) => s.get_ref().shutdown(how),
-            #[cfg(feature = "rustls-tls")]
-            InnerNetworkStream::RustlsTls(ref s) => s.get_ref().shutdown(how),
-            InnerNetworkStream::None => {
-                debug_assert!(false, "InnerNetworkStream::None must never be built");
-                Ok(())
-            }
-        }
-    }
-
-    pub fn connect<T: ToSocketAddrs>(
-        server: T,
-        timeout: Option<Duration>,
-        tls_parameters: Option<&TlsParameters>,
-    ) -> Result<NetworkStream, Error> {
-        fn try_connect_timeout<T: ToSocketAddrs>(
-            server: T,
-            timeout: Duration,
-        ) -> Result<TcpStream, Error> {
-            let addrs = server.to_socket_addrs().map_err(error::connection)?;
-            for addr in addrs {
-                if let Ok(result) = TcpStream::connect_timeout(&addr, timeout) {
-                    return Ok(result);
-                }
-            }
-            Err(error::connection("Could not connect"))
-        }
-
-        let tcp_stream = match timeout {
-            Some(t) => try_connect_timeout(server, t)?,
-            None => TcpStream::connect(server).map_err(error::connection)?,
-        };
-
-        let mut stream = NetworkStream::new(InnerNetworkStream::Tcp(tcp_stream));
-        if let Some(tls_parameters) = tls_parameters {
-            stream.upgrade_tls(tls_parameters)?;
-        }
-        Ok(stream)
-    }
-
-    pub fn upgrade_tls(&mut self, tls_parameters: &TlsParameters) -> Result<(), Error> {
-        match &self.inner {
-            #[cfg(not(any(feature = "native-tls", feature = "rustls-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"))]
-            InnerNetworkStream::Tcp(_) => {
-                // get owned TcpStream
-                let tcp_stream = mem::replace(&mut self.inner, InnerNetworkStream::None);
-                let tcp_stream = match tcp_stream {
-                    InnerNetworkStream::Tcp(tcp_stream) => tcp_stream,
-                    _ => unreachable!(),
-                };
-
-                self.inner = Self::upgrade_tls_impl(tcp_stream, tls_parameters)?;
-                Ok(())
-            }
-            _ => Ok(()),
-        }
-    }
-
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
-    fn upgrade_tls_impl(
-        tcp_stream: TcpStream,
-        tls_parameters: &TlsParameters,
-    ) -> Result<InnerNetworkStream, Error> {
-        Ok(match &tls_parameters.connector {
-            #[cfg(feature = "native-tls")]
-            InnerTlsParameters::NativeTls(connector) => {
-                let stream = connector
-                    .connect(tls_parameters.domain(), tcp_stream)
-                    .map_err(error::connection)?;
-                InnerNetworkStream::NativeTls(stream)
-            }
-            #[cfg(feature = "rustls-tls")]
-            InnerTlsParameters::RustlsTls(connector) => {
-                use webpki::DNSNameRef;
-
-                let domain = DNSNameRef::try_from_ascii_str(tls_parameters.domain())
-                    .map_err(error::connection)?;
-                let stream = StreamOwned::new(ClientSession::new(&connector, domain), tcp_stream);
-
-                InnerNetworkStream::RustlsTls(stream)
-            }
-        })
-    }
-
-    pub fn is_encrypted(&self) -> bool {
-        match self.inner {
-            InnerNetworkStream::Tcp(_) => false,
-            #[cfg(feature = "native-tls")]
-            InnerNetworkStream::NativeTls(_) => true,
-            #[cfg(feature = "rustls-tls")]
-            InnerNetworkStream::RustlsTls(_) => true,
-            InnerNetworkStream::None => {
-                debug_assert!(false, "InnerNetworkStream::None must never be built");
-                false
-            }
-        }
-    }
-
-    pub fn set_read_timeout(&mut self, duration: Option<Duration>) -> io::Result<()> {
-        match self.inner {
-            InnerNetworkStream::Tcp(ref mut stream) => stream.set_read_timeout(duration),
-            #[cfg(feature = "native-tls")]
-            InnerNetworkStream::NativeTls(ref mut stream) => {
-                stream.get_ref().set_read_timeout(duration)
-            }
-            #[cfg(feature = "rustls-tls")]
-            InnerNetworkStream::RustlsTls(ref mut stream) => {
-                stream.get_ref().set_read_timeout(duration)
-            }
-            InnerNetworkStream::None => {
-                debug_assert!(false, "InnerNetworkStream::None must never be built");
-                Ok(())
-            }
-        }
-    }
-
-    /// Set write timeout for IO calls
-    pub fn set_write_timeout(&mut self, duration: Option<Duration>) -> io::Result<()> {
-        match self.inner {
-            InnerNetworkStream::Tcp(ref mut stream) => stream.set_write_timeout(duration),
-
-            #[cfg(feature = "native-tls")]
-            InnerNetworkStream::NativeTls(ref mut stream) => {
-                stream.get_ref().set_write_timeout(duration)
-            }
-            #[cfg(feature = "rustls-tls")]
-            InnerNetworkStream::RustlsTls(ref mut stream) => {
-                stream.get_ref().set_write_timeout(duration)
-            }
-
-            InnerNetworkStream::None => {
-                debug_assert!(false, "InnerNetworkStream::None must never be built");
-                Ok(())
-            }
-        }
-    }
-}
-
-impl Read for NetworkStream {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        match self.inner {
-            InnerNetworkStream::Tcp(ref mut s) => s.read(buf),
-            #[cfg(feature = "native-tls")]
-            InnerNetworkStream::NativeTls(ref mut s) => s.read(buf),
-            #[cfg(feature = "rustls-tls")]
-            InnerNetworkStream::RustlsTls(ref mut s) => s.read(buf),
-            InnerNetworkStream::None => {
-                debug_assert!(false, "InnerNetworkStream::None must never be built");
-                Ok(0)
-            }
-        }
-    }
-}
-
-impl Write for NetworkStream {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        match self.inner {
-            InnerNetworkStream::Tcp(ref mut s) => s.write(buf),
-            #[cfg(feature = "native-tls")]
-            InnerNetworkStream::NativeTls(ref mut s) => s.write(buf),
-            #[cfg(feature = "rustls-tls")]
-            InnerNetworkStream::RustlsTls(ref mut s) => s.write(buf),
-            InnerNetworkStream::None => {
-                debug_assert!(false, "InnerNetworkStream::None must never be built");
-                Ok(0)
-            }
-        }
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        match self.inner {
-            InnerNetworkStream::Tcp(ref mut s) => s.flush(),
-            #[cfg(feature = "native-tls")]
-            InnerNetworkStream::NativeTls(ref mut s) => s.flush(),
-            #[cfg(feature = "rustls-tls")]
-            InnerNetworkStream::RustlsTls(ref mut s) => s.flush(),
-            InnerNetworkStream::None => {
-                debug_assert!(false, "InnerNetworkStream::None must never be built");
-                Ok(())
-            }
-        }
-    }
-}

src/transport/smtp/client/tls.rs

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