Merge pull request #302 from kper/v0.8.x

Add `Reference` and `In-Reply-To` to the email header.

.appveyor.yml

@@ -1,23 +1,14 @@
 environment:
-    CARGO_TARGET: x86_64-pc-windows-gnu
-    matrix:
-        - TARGET: x86_64-pc-windows-msvc
-        - TARGET: i686-pc-windows-gnu
+  matrix:
+    - TARGET: x86_64-pc-windows-msvc
 install:
-    - ps: Start-FileDownload "https://static.rust-lang.org/dist/rustc-nightly-${env:TARGET}.tar.gz"
-    - ps: Start-FileDownload "https://static.rust-lang.org/cargo-dist/cargo-nightly-${env:CARGO_TARGET}.tar.gz"
-    - 7z x rustc-nightly-%TARGET%.tar.gz > nul
-    - 7z x rustc-nightly-%TARGET%.tar > nul
-    - 7z x cargo-nightly-%CARGO_TARGET%.tar.gz > nul
-    - 7z x cargo-nightly-%CARGO_TARGET%.tar > nul
-    - call "C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\vcvarsall.bat" amd64
-    - set PATH=%PATH%;%cd%/rustc-nightly-%TARGET%/rustc/bin
-    - set PATH=%PATH%;%cd%/cargo-nightly-%CARGO_TARGET%/cargo/bin
-    - SET PATH=%PATH%;C:\MinGW\bin
-    - rustc -V
-    - cargo -V
-
+  - 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 test --verbose --no-default-features
+  - 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

.clog.toml

@@ -0,0 +1,7 @@
+[clog]
+repository = "https://github.com/lettre/lettre"
+changelog = "CHANGELOG.md"
+
+[sections]
+Style = ["style"]
+Documentation = ["docs"]

.gitignore

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

.travis.yml

@@ -1,21 +1,31 @@
 language: rust
-sudo: required
-
 rust:
-  - stable
-  - beta
-  - nightly
+- 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:
-  - pip install 'travis-cargo<0.2' --user && export PATH=$HOME/.local/bin:$PATH
+- 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:
-  - |
-      travis-cargo build &&
-      travis-cargo test &&
-      travis-cargo doc
+- cargo test --verbose --all
 after_success:
-  - travis-cargo --only stable doc-upload
-  - travis-cargo --only stable coveralls
-
-env:
-  global:
-    secure: "MaZ3TzuaAHuxmxQkfJdqRfkh7/ieScJRk0T/2yjysZhDMTYyRmp5wh/zkfW1ADuG0uc4Pqsxrsh1J9SVO7O0U5NJA8NKZi/pgiL+FHh0g4YtlHxy2xmFNB5am3Kyc+E7B4XylwTbA9S8ublVM0nvX7yX/a5fbwEUInVk2bA8fpc="
+- ./.build-scripts/codecov.sh
+- '[ "$TRAVIS_BRANCH" = "v0.8.x" ] && [ $TRAVIS_PULL_REQUEST = false ] && ./.build-scripts/site-upload.sh'

CHANGELOG.md

@@ -0,0 +1,123 @@
+<a name="v0.8.2"></a>
+### v0.8.2 (2018-05-03)
+
+
+#### Bug Fixes
+
+* **transport:**  Write timeout is not set in smtp transport ([cc3580a8](https://github.com/lettre/lettre/commit/cc3580a8942e11c2addf6677f05e16fb451c7ea0))
+
+#### Style
+
+* **all:**  Fix typos ([360c42ff](https://github.com/lettre/lettre/commit/360c42ffb8f706222eaad14e72619df1e4857814))
+
+#### Features
+
+* **all:**
+  *  Add set -xe option to build scripts ([57bbabaa](https://github.com/lettre/lettre/commit/57bbabaa6a10cc1a4de6f379e25babfee7adf6ad))
+  *  Move post-success scripts to separate files ([3177b58c](https://github.com/lettre/lettre/commit/3177b58c6d11ffae73c958713f6f0084173924e1))
+  *  Add website upload to travis build script ([a5294df6](https://github.com/lettre/lettre/commit/a5294df63728e14e24eeb851bb4403abd6a7bd36))
+  *  Add codecov upload in travis ([a03bfa00](https://github.com/lettre/lettre/commit/a03bfa008537b1d86ff789d0823e89ad5d99bd79))
+  *  Update README to put useful links at the top ([1ebbe660](https://github.com/lettre/lettre/commit/1ebbe660f5e142712f702c02d5d1e45211763b42))
+  *  Update badges in README and Cargo.toml ([f7ee5c42](https://github.com/lettre/lettre/commit/f7ee5c427ad71e4295f2f1d8e3e9e2dd850223e8))
+  *  Move docs from hugo to gitbook ([27935e32](https://github.com/lettre/lettre/commit/27935e32ef097db8db004569f35cad1d6cd30eca))
+* **transport:**  Use md-5 and hmac instead of rust-crypto ([0cf018a8](https://github.com/lettre/lettre/commit/0cf018a85e4ea1ad16c7216670da560cc915ec32))
+
+
+
+<a name="v0.8.1"></a>
+### v0.8.1 (2018-04-11)
+
+#### Fix
+
+* **all:**
+  *  Replace skeptic by some custom rustdoc invocations ([81bad131](https://github.com/lettre/lettre/commit/81bad1317519d330c46ea02f2b7a266b97cc00dd))
+
+#### Documentation
+
+* **all:**
+  *  Add changelog sections for style and docs ([b4d03ead](https://github.com/lettre/lettre/commit/b4d03ead8cce04e0c3d65a30e7a07acca9530f30))
+  *  Use clog to generate changelogs ([8981a775](https://github.com/lettre/lettre/commit/8981a7758c89be69974ef204c4390744aea94e4f), closes [#233](https://github.com/lettre/lettre/issues/233))
+
+#### Style
+
+* **transport-smtp:**  Avoid useless empty format strings ([f3271715](https://github.com/lettre/lettre/commit/f3271715ecaf2793c9064462184867e4f22b0ead))
+
+
+
+<a name="v0.8.0"></a>
+### v0.8.0 (2018-03-31)
+
+#### Added
+
+* Support binary files as attachment
+* Move doc to a dedicated website
+* Add tests for the doc using skeptic
+* Added a code of conduct
+* Use hostname as `ClientId` when available
+
+#### Changed
+
+* Detail in SMTP Response is now an enum
+* Use nom for parsing smtp responses
+* `Envelope` was moved from `lettre_email` to `lettre`
+* `EmailAddress::new()` now returns a `Result`
+* `SendableEmail` replaces `from` and `to` by `envelope` that returns an `Envelope`
+* `File` transport storage format has changed
+
+#### Fixed
+
+* Add missing "Bcc" headers when building the email
+* Specify utf-8 charset for html
+* Use parts for text and html methods to work with attachments
+
+#### Removed
+
+* `get_ehlo` and `reset` in SmtpTransport are now private
+
+<a name="v0.7.0"></a>
+### v0.7.0 (2017-10-08)
+
+#### Added
+
+* Allow validating server certificate
+* Initial (incomplete) attachments support
+
+#### Changed
+
+* Split into the *lettre* and *lettre_email* crates
+* A lot of small improvements
+* Use *tls-native* instead of *openssl* in smtp transport
+
+<a name="v0.6.2"></a>
+### v0.6.2 (2017-02-18)
+
+#### Changed
+
+* Update env-logger crate to 0.4
+* Update openssl crate to 0.9
+* Update uuid crate to 0.4
+
+<a name="v0.6.1"></a>
+### v0.6.1 (2016-10-19)
+
+#### Changes
+
+* **documentation**
+  * #91: Build separate docs for each release
+  * #96: Add complete documentation information to README
+
+#### Fixed
+
+* #85: Use address-list for "To", "From" etc.
+* #93: Force building tests before coverage computing
+
+<a name="v0.6.0"></a>
+### v0.6.0 (2016-05-05)
+
+#### Changes
+
+*  multipart support
+*  add non-consuming methods for Email builders
+* `add_header` does not return the builder anymore, 
+  for consistency with other methods. Use the `header`
+  method instead

CODE_OF_CONDUCT.md

@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+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 [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

CONTRIBUTING.md

@@ -0,0 +1,35 @@
+## Contributing to Lettre
+
+The following guidelines are inspired from the [hyper project](https://github.com/hyperium/hyper/blob/master/CONTRIBUTING.md).
+
+### Code formatting
+
+All code must be formatted using `rustfmt`.
+
+### Commit Message Format
+
+Each commit message consists of a header, a body and a footer. The header has a special format that includes a type, a scope and a subject:
+
+```text
+<type>(<scope>): <subject> <BLANK LINE> <body> <BLANK LINE> <footer>
+```
+
+Any line of the commit message cannot be longer 72 characters.
+
+**type** must be one of the following:
+
+    feat: A new feature
+    fix: A bug fix
+    docs: Documentation only changes
+    style: Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)
+    perf: A code change that improves performance
+
+**scope** is the lettre part that is being touched. Examples:
+
+    email
+    transport-smtp
+    transport-file
+    transport
+    all
+
+The body explains the change, and the footer contains relevant changelog notes and references to fixed issues.

Cargo.toml

@@ -1,27 +1,5 @@
-[package]
-
-name = "smtp"
-version = "0.3.0"
-description = "Simple SMTP client"
-readme = "README.md"
-documentation = "http://amousset.me/rust-smtp/smtp/"
-repository = "https://github.com/amousset/rust-smtp"
-license = "MIT"
-authors = ["Alexis Mousset <alexis.mousset@gmx.fr>"]
-keywords = ["email", "smtp", "mailer"]
-
-[dependencies]
-time = "0.1"
-uuid = "0.1"
-log = "0.3"
-rustc-serialize = "0.3"
-rust-crypto = "0.2"
-bufstream = "0.1"
-email = "0.0"
-openssl = "0.6"
-
-[dev-dependencies]
-env_logger = "0.3"
-
-[features]
-unstable = []
+[workspace]
+members = [
+    "lettre",
+    "lettre_email",
+]

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Alexis Mousset
+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,22 +1,94 @@
-rust-smtp [![Build Status](https://travis-ci.org/amousset/rust-smtp.svg?branch=master)](https://travis-ci.org/amousset/rust-smtp) [![Coverage Status](https://coveralls.io/repos/github/amousset/rust-smtp/badge.svg?branch=master)](https://coveralls.io/github/amousset/rust-smtp?branch=master) [![Crate](https://meritbadge.herokuapp.com/smtp)](https://crates.io/crates/smtp) [![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
-=========
+# lettre
 
-This library implements a simple SMTP client.
-See the [documentation](http://amousset.github.io/rust-smtp/smtp/) for more information.
+**Lettre is a mailer library for Rust.**
 
-Install
--------
+[![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)
 
+[![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")
+
+Useful links:
+
+* [User documentation](http://lettre.at/)
+* [API documentation](https://docs.rs/lettre/)
+* [Changelog](https://github.com/lettre/lettre/blob/master/CHANGELOG.md)
+
+---
+
+## Features
+
+Lettre provides the following features:
+
+* Multiple transport methods
+* Unicode support (for email content and addresses)
+* Secure delivery with SMTP using encryption and authentication
+* Easy email builders
+
+## Example
+
+This library requires Rust 1.20 or newer.
 To use this library, add the following to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-smtp = "0.2"
+lettre = "0.8"
+lettre_email = "0.8"
 ```
 
-License
--------
+```rust,no_run
+extern crate lettre;
+extern crate lettre_email;
+
+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.")
+        .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());
+}
+```
+
+## Testing
+
+The `lettre` tests require an open mail server listening locally on port 2525 and the `sendmail` command.
+
+## Code of conduct
+
+Anyone who interacts with Lettre in any space, including but not limited to
+this GitHub repository, must follow our [code of conduct](https://github.com/lettre/lettre/blob/master/CODE_OF_CONDUCT.md).
+
+## License
 
 This program is distributed under the terms of the MIT license.
 
-See LICENSE for details.
+See [LICENSE](./LICENSE) for details.

examples/client.rs

@@ -1,54 +0,0 @@
-#[macro_use]
-extern crate log;
-extern crate env_logger;
-extern crate smtp;
-
-use std::sync::{Arc, Mutex};
-use std::thread;
-
-use smtp::sender::SenderBuilder;
-use smtp::email::EmailBuilder;
-
-fn main() {
-    env_logger::init().unwrap();
-
-    let sender = Arc::new(Mutex::new(SenderBuilder::localhost().unwrap().hello_name("localhost")
-        .enable_connection_reuse(true).build()));
-
-	let mut threads = Vec::new();
-    for _ in 1..5 {
-
-    	let th_sender = sender.clone();
-    	threads.push(thread::spawn(move || {
-
-        	let email = EmailBuilder::new()
-                    	.to("user@localhost")
-                    	.from("user@localhost")
-                    	.body("Hello World!")
-                    	.subject("Hello")
-                    	.build();
-
-    		let _ = th_sender.lock().unwrap().send(email);
-		}));
-    }
-
-    for thread in threads {
-    	let _ = thread.join();
-    }
-
-    let email = EmailBuilder::new()
-                    .to("user@localhost")
-                    .from("user@localhost")
-                    .body("Hello World!")
-                    .subject("Hello Bis")
-                    .build();
-
-	let mut sender = sender.lock().unwrap();
-    let result = sender.send(email);
-    sender.close();
-
-    match result {
-        Ok(..) => info!("Email sent successfully"),
-        Err(error) => error!("{:?}", error),
-    }
-}

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 = "^4.0", 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::ErrorKind),
+}
+
+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(_) => None,
+            _ => 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::ErrorKind> for Error {
+    fn from(err: nom::ErrorKind) -> 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

@@ -0,0 +1,396 @@
+//! ESMTP features
+
+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-impls", derive(Serialize, Deserialize))]
+pub enum ClientId {
+    /// A fully-qualified domain name
+    Domain(String),
+    /// An IPv4 address
+    Ipv4(Ipv4Addr),
+    /// An IPv6 address
+    Ipv6(Ipv6Addr),
+}
+
+impl Display for ClientId {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match *self {
+            ClientId::Domain(ref value) => f.write_str(value),
+            ClientId::Ipv4(ref value) => write!(f, "{}", value),
+            ClientId::Ipv6(ref value) => write!(f, "{}", value),
+        }
+    }
+}
+
+impl ClientId {
+    /// Creates a new `ClientId` from a fully qualified domain name
+    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-impls", derive(Serialize, Deserialize))]
+pub enum Extension {
+    /// 8BITMIME keyword
+    ///
+    /// RFC 6152: https://tools.ietf.org/html/rfc6152
+    EightBitMime,
+    /// SMTPUTF8 keyword
+    ///
+    /// RFC 6531: https://tools.ietf.org/html/rfc6531
+    SmtpUtfEight,
+    /// STARTTLS keyword
+    ///
+    /// 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 {
+        match *self {
+            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)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub struct ServerInfo {
+    /// Server name
+    ///
+    /// The name given in the server banner
+    pub name: String,
+    /// ESMTP features supported by the server
+    ///
+    /// It contains the features supported by the server and known by the `Extension` module.
+    pub features: HashSet<Extension>,
+}
+
+impl Display for ServerInfo {
+    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)
+            }
+        )
+    }
+}
+
+impl ServerInfo {
+    /// Parses a EHLO response to create a `ServerInfo`
+    pub fn from_response(response: &Response) -> Result<ServerInfo, Error> {
+        let name = match response.first_word() {
+            Some(name) => name,
+            None => return Err(Error::ResponseParsing("Could not read server name")),
+        };
+
+        let mut features: HashSet<Extension> = HashSet::new();
+
+        for line in response.message.as_slice() {
+            if line.is_empty() {
+                continue;
+            }
+
+            let split: Vec<&str> = line.split_whitespace().collect();
+            match split[0] {
+                "8BITMIME" => {
+                    features.insert(Extension::EightBitMime);
+                }
+                "SMTPUTF8" => {
+                    features.insert(Extension::SmtpUtfEight);
+                }
+                "STARTTLS" => {
+                    features.insert(Extension::StartTls);
+                }
+                "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));
+                        }
+                        _ => (),
+                    }
+                },
+                _ => (),
+            };
+        }
+
+        Ok(ServerInfo {
+            name: name.to_string(),
+            features,
+        })
+    }
+
+    /// Checks if the server supports an ESMTP feature
+    pub fn supports_feature(&self, keyword: Extension) -> bool {
+        self.features.contains(&keyword)
+    }
+
+    /// Checks if the server supports an ESMTP feature
+    pub fn supports_auth_mechanism(&self, mechanism: Mechanism) -> bool {
+        self.features
+            .contains(&Extension::Authentication(mechanism))
+    }
+}
+
+/// A `MAIL FROM` extension parameter
+#[derive(PartialEq, Eq, Clone, Debug)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub enum MailParameter {
+    /// `BODY` parameter
+    Body(MailBodyParameter),
+    /// `SIZE` parameter
+    Size(usize),
+    /// `SMTPUTF8` parameter
+    SmtpUtfEight,
+    /// Custom parameter
+    Other {
+        /// Parameter keyword
+        keyword: String,
+        /// Parameter value
+        value: Option<String>,
+    },
+}
+
+impl Display for MailParameter {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match *self {
+            MailParameter::Body(ref value) => write!(f, "BODY={}", value),
+            MailParameter::Size(size) => write!(f, "SIZE={}", size),
+            MailParameter::SmtpUtfEight => f.write_str("SMTPUTF8"),
+            MailParameter::Other {
+                ref keyword,
+                value: Some(ref value),
+            } => write!(f, "{}={}", keyword, XText(value)),
+            MailParameter::Other {
+                ref keyword,
+                value: None,
+            } => f.write_str(keyword),
+        }
+    }
+}
+
+/// Values for the `BODY` parameter to `MAIL FROM`
+#[derive(PartialEq, Eq, Clone, Debug, Copy)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub enum MailBodyParameter {
+    /// `7BIT`
+    SevenBit,
+    /// `8BITMIME`
+    EightBitMime,
+}
+
+impl Display for MailBodyParameter {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match *self {
+            MailBodyParameter::SevenBit => f.write_str("7BIT"),
+            MailBodyParameter::EightBitMime => f.write_str("8BITMIME"),
+        }
+    }
+}
+
+/// A `RCPT TO` extension parameter
+#[derive(PartialEq, Eq, Clone, Debug)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub enum RcptParameter {
+    /// Custom parameter
+    Other {
+        /// Parameter keyword
+        keyword: String,
+        /// Parameter value
+        value: Option<String>,
+    },
+}
+
+impl Display for RcptParameter {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match *self {
+            RcptParameter::Other {
+                ref keyword,
+                value: Some(ref value),
+            } => write!(f, "{}={}", keyword, XText(value)),
+            RcptParameter::Other {
+                ref keyword,
+                value: None,
+            } => f.write_str(keyword),
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+
+    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::new("test".to_string())),
+            "test".to_string()
+        );
+    }
+
+    #[test]
+    fn test_extension_fmt() {
+        assert_eq!(
+            format!("{}", Extension::EightBitMime),
+            "8BITMIME".to_string()
+        );
+        assert_eq!(
+            format!("{}", Extension::Authentication(Mechanism::Plain)),
+            "AUTH PLAIN".to_string()
+        );
+    }
+
+    #[test]
+    fn test_serverinfo_fmt() {
+        let mut eightbitmime = HashSet::new();
+        assert!(eightbitmime.insert(Extension::EightBitMime));
+
+        assert_eq!(
+            format!(
+                "{}",
+                ServerInfo {
+                    name: "name".to_string(),
+                    features: eightbitmime.clone(),
+                }
+            ),
+            "name with {EightBitMime}".to_string()
+        );
+
+        let empty = HashSet::new();
+
+        assert_eq!(
+            format!(
+                "{}",
+                ServerInfo {
+                    name: "name".to_string(),
+                    features: empty,
+                }
+            ),
+            "name with no supported features".to_string()
+        );
+
+        let mut plain = HashSet::new();
+        assert!(plain.insert(Extension::Authentication(Mechanism::Plain)));
+
+        assert_eq!(
+            format!(
+                "{}",
+                ServerInfo {
+                    name: "name".to_string(),
+                    features: plain.clone(),
+                }
+            ),
+            "name with {Authentication(Plain)}".to_string()
+        );
+    }
+
+    #[test]
+    fn test_serverinfo() {
+        let response = Response::new(
+            Code::new(
+                Severity::PositiveCompletion,
+                Category::Unspecified4,
+                Detail::One,
+            ),
+            vec![
+                "me".to_string(),
+                "8BITMIME".to_string(),
+                "SIZE 42".to_string(),
+            ],
+        );
+
+        let mut features = HashSet::new();
+        assert!(features.insert(Extension::EightBitMime));
+
+        let server_info = ServerInfo {
+            name: "me".to_string(),
+            features,
+        };
+
+        assert_eq!(ServerInfo::from_response(&response).unwrap(), server_info);
+
+        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(
+                Severity::PositiveCompletion,
+                Category::Unspecified4,
+                Detail::One,
+            ),
+            vec![
+                "me".to_string(),
+                "AUTH PLAIN CRAM-MD5 OTHER".to_string(),
+                "8BITMIME".to_string(),
+                "SIZE 42".to_string(),
+            ],
+        );
+
+        let mut features2 = HashSet::new();
+        assert!(features2.insert(Extension::EightBitMime));
+        assert!(features2.insert(Extension::Authentication(Mechanism::Plain),));
+        #[cfg(feature = "crammd5-auth")]
+        assert!(features2.insert(Extension::Authentication(Mechanism::CramMd5),));
+
+        let server_info2 = ServerInfo {
+            name: "me".to_string(),
+            features: features2,
+        };
+
+        assert_eq!(ServerInfo::from_response(&response2).unwrap(), server_info2);
+
+        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

@@ -0,0 +1,547 @@
+//! SMTP response, containing a mandatory return code and an optional text
+//! message
+
+use nom::{crlf, ErrorKind as NomErrorKind};
+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-impls", derive(Serialize, Deserialize))]
+pub enum Severity {
+    /// 2yx
+    PositiveCompletion = 2,
+    /// 3yz
+    PositiveIntermediate = 3,
+    /// 4yz
+    TransientNegativeCompletion = 4,
+    /// 5yz
+    PermanentNegativeCompletion = 5,
+}
+
+impl Display for Severity {
+    fn fmt(&self, f: &mut Formatter) -> Result {
+        write!(f, "{}", *self as u8)
+    }
+}
+
+/// Second digit
+#[derive(PartialEq, Eq, Copy, Clone, Debug)]
+#[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
+pub enum Category {
+    /// x0z
+    Syntax = 0,
+    /// x1z
+    Information = 1,
+    /// x2z
+    Connections = 2,
+    /// x3z
+    Unspecified3 = 3,
+    /// x4z
+    Unspecified4 = 4,
+    /// x5z
+    MailSystem = 5,
+}
+
+impl Display for Category {
+    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-impls", derive(Serialize, Deserialize))]
+pub enum Detail {
+    #[allow(missing_docs)]
+    Zero = 0,
+    #[allow(missing_docs)]
+    One = 1,
+    #[allow(missing_docs)]
+    Two = 2,
+    #[allow(missing_docs)]
+    Three = 3,
+    #[allow(missing_docs)]
+    Four = 4,
+    #[allow(missing_docs)]
+    Five = 5,
+    #[allow(missing_docs)]
+    Six = 6,
+    #[allow(missing_docs)]
+    Seven = 7,
+    #[allow(missing_docs)]
+    Eight = 8,
+    #[allow(missing_docs)]
+    Nine = 9,
+}
+
+impl Display for Detail {
+    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-impls", derive(Serialize, Deserialize))]
+pub struct Code {
+    /// First digit of the response code
+    pub severity: Severity,
+    /// Second digit of the response code
+    pub category: Category,
+    /// Third digit
+    pub detail: Detail,
+}
+
+impl Display for Code {
+    fn fmt(&self, f: &mut Formatter) -> Result {
+        write!(f, "{}{}{}", self.severity, self.category, self.detail)
+    }
+}
+
+impl Code {
+    /// Creates a new `Code` structure
+    pub fn new(severity: Severity, category: Category, detail: Detail) -> Code {
+        Code {
+            severity,
+            category,
+            detail,
+        }
+    }
+}
+
+/// 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-impls", derive(Serialize, Deserialize))]
+pub struct Response {
+    /// Response code
+    pub code: Code,
+    /// Server response string (optional)
+    /// Handle multiline responses
+    pub message: Vec<String>,
+}
+
+impl FromStr for Response {
+    type Err = NomErrorKind;
+
+    fn from_str(s: &str) -> result::Result<Response, NomErrorKind> {
+        match parse_response(s.as_bytes()) {
+            Ok((_, res)) => Ok(res),
+            Err(e) => Err(e.into_error_kind()),
+        }
+    }
+}
+
+impl Response {
+    /// Creates a new `Response`
+    pub fn new(code: Code, message: Vec<String>) -> Response {
+        Response { code, message }
+    }
+
+    /// Tells if the response is positive
+    pub fn is_positive(&self) -> bool {
+        match self.code.severity {
+            Severity::PositiveCompletion | Severity::PositiveIntermediate => true,
+            _ => false,
+        }
+    }
+
+    /// Tests code equality
+    pub fn has_code(&self, code: u16) -> bool {
+        self.code.to_string() == code.to_string()
+    }
+
+    /// Returns only the first word of the message if possible
+    pub fn first_word(&self) -> Option<&str> {
+        self.message
+            .get(0)
+            .and_then(|line| line.split_whitespace().next())
+    }
+
+    /// Returns only the line of the message if possible
+    pub fn first_line(&self) -> Option<&str> {
+        self.message.first().map(String::as_str)
+    }
+}
+
+// Parsers (originally from tokio-smtp)
+
+named!(
+    parse_code<Code>,
+    map!(
+        tuple!(parse_severity, parse_category, parse_detail),
+        |(severity, category, detail)| Code {
+            severity,
+            category,
+            detail,
+        }
+    )
+);
+
+named!(
+    parse_severity<Severity>,
+    alt!(
+        tag!("2") => { |_| Severity::PositiveCompletion } |
+        tag!("3") => { |_| Severity::PositiveIntermediate } |
+        tag!("4") => { |_| Severity::TransientNegativeCompletion } |
+        tag!("5") => { |_| Severity::PermanentNegativeCompletion }
+    )
+);
+
+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 }
+    )
+);
+
+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 }
+    )
+);
+
+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(());
+            }
+
+            // 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);
+            }
+
+            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::{Category, Code, Detail, Response, Severity};
+
+    #[test]
+    fn test_severity_fmt() {
+        assert_eq!(format!("{}", Severity::PositiveCompletion), "2");
+    }
+
+    #[test]
+    fn test_category_fmt() {
+        assert_eq!(format!("{}", Category::Unspecified4), "4");
+    }
+
+    #[test]
+    fn test_code_new() {
+        assert_eq!(
+            Code::new(
+                Severity::TransientNegativeCompletion,
+                Category::Connections,
+                Detail::Zero,
+            ),
+            Code {
+                severity: Severity::TransientNegativeCompletion,
+                category: Category::Connections,
+                detail: Detail::Zero,
+            }
+        );
+    }
+
+    #[test]
+    fn test_code_display() {
+        let code = Code {
+            severity: Severity::TransientNegativeCompletion,
+            category: Category::Connections,
+            detail: Detail::One,
+        };
+
+        assert_eq!(code.to_string(), "421");
+    }
+
+    #[test]
+    fn test_response_from_str() {
+        let raw_response = "250-me\r\n250-8BITMIME\r\n250-SIZE 42\r\n250 AUTH PLAIN CRAM-MD5\r\n";
+        assert_eq!(
+            raw_response.parse::<Response>().unwrap(),
+            Response {
+                code: Code {
+                    severity: Severity::PositiveCompletion,
+                    category: Category::MailSystem,
+                    detail: Detail::Zero,
+                },
+                message: vec![
+                    "me".to_string(),
+                    "8BITMIME".to_string(),
+                    "SIZE 42".to_string(),
+                    "AUTH PLAIN CRAM-MD5".to_string(),
+                ],
+            }
+        );
+
+        let wrong_code = "2506-me\r\n250-8BITMIME\r\n250-SIZE 42\r\n250 AUTH PLAIN CRAM-MD5\r\n";
+        assert!(wrong_code.parse::<Response>().is_err());
+
+        let wrong_end = "250-me\r\n250-8BITMIME\r\n250-SIZE 42\r\n250-AUTH PLAIN CRAM-MD5\r\n";
+        assert!(wrong_end.parse::<Response>().is_err());
+    }
+
+    #[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::TransientNegativeCompletion,
+                category: Category::MailSystem,
+                detail: Detail::Zero,
+            },
+            vec![
+                "me".to_string(),
+                "8BITMIME".to_string(),
+                "SIZE 42".to_string(),
+            ],
+        ).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(251));
+    }
+
+    #[test]
+    fn test_response_first_word() {
+        assert_eq!(
+            Response::new(
+                Code {
+                    severity: Severity::TransientNegativeCompletion,
+                    category: Category::MailSystem,
+                    detail: Detail::One,
+                },
+                vec![
+                    "me".to_string(),
+                    "8BITMIME".to_string(),
+                    "SIZE 42".to_string(),
+                ],
+            ).first_word(),
+            Some("me")
+        );
+        assert_eq!(
+            Response::new(
+                Code {
+                    severity: Severity::TransientNegativeCompletion,
+                    category: Category::MailSystem,
+                    detail: Detail::One,
+                },
+                vec![
+                    "me mo".to_string(),
+                    "8BITMIME".to_string(),
+                    "SIZE 42".to_string(),
+                ],
+            ).first_word(),
+            Some("me")
+        );
+        assert_eq!(
+            Response::new(
+                Code {
+                    severity: Severity::TransientNegativeCompletion,
+                    category: Category::MailSystem,
+                    detail: Detail::One,
+                },
+                vec![],
+            ).first_word(),
+            None
+        );
+        assert_eq!(
+            Response::new(
+                Code {
+                    severity: Severity::TransientNegativeCompletion,
+                    category: Category::MailSystem,
+                    detail: Detail::One,
+                },
+                vec![" ".to_string()],
+            ).first_word(),
+            None
+        );
+        assert_eq!(
+            Response::new(
+                Code {
+                    severity: Severity::TransientNegativeCompletion,
+                    category: Category::MailSystem,
+                    detail: Detail::One,
+                },
+                vec!["  ".to_string()],
+            ).first_word(),
+            None
+        );
+        assert_eq!(
+            Response::new(
+                Code {
+                    severity: Severity::TransientNegativeCompletion,
+                    category: Category::MailSystem,
+                    detail: Detail::One,
+                },
+                vec!["".to_string()],
+            ).first_word(),
+            None
+        );
+    }
+
+    #[test]
+    fn test_response_first_line() {
+        assert_eq!(
+            Response::new(
+                Code {
+                    severity: Severity::TransientNegativeCompletion,
+                    category: Category::MailSystem,
+                    detail: Detail::One,
+                },
+                vec![
+                    "me".to_string(),
+                    "8BITMIME".to_string(),
+                    "SIZE 42".to_string(),
+                ],
+            ).first_line(),
+            Some("me")
+        );
+        assert_eq!(
+            Response::new(
+                Code {
+                    severity: Severity::TransientNegativeCompletion,
+                    category: Category::MailSystem,
+                    detail: Detail::One,
+                },
+                vec![
+                    "me mo".to_string(),
+                    "8BITMIME".to_string(),
+                    "SIZE 42".to_string(),
+                ],
+            ).first_line(),
+            Some("me mo")
+        );
+        assert_eq!(
+            Response::new(
+                Code {
+                    severity: Severity::TransientNegativeCompletion,
+                    category: Category::MailSystem,
+                    detail: Detail::One,
+                },
+                vec![],
+            ).first_line(),
+            None
+        );
+        assert_eq!(
+            Response::new(
+                Code {
+                    severity: Severity::TransientNegativeCompletion,
+                    category: Category::MailSystem,
+                    detail: Detail::One,
+                },
+                vec![" ".to_string()],
+            ).first_line(),
+            Some(" ")
+        );
+        assert_eq!(
+            Response::new(
+                Code {
+                    severity: Severity::TransientNegativeCompletion,
+                    category: Category::MailSystem,
+                    detail: Detail::One,
+                },
+                vec!["  ".to_string()],
+            ).first_line(),
+            Some("  ")
+        );
+        assert_eq!(
+            Response::new(
+                Code {
+                    severity: Severity::TransientNegativeCompletion,
+                    category: Category::MailSystem,
+                    detail: Detail::One,
+                },
+                vec!["".to_string()],
+            ).first_line(),
+            Some("")
+        );
+    }
+}

lettre/src/smtp/util.rs

@@ -0,0 +1,46 @@
+//! Utils for string manipulation
+
+use std::fmt::{Display, Formatter, Result as FmtResult};
+
+/// Encode a string as xtext
+#[derive(Debug)]
+#[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 {
+        let mut rest = self.0;
+        while let Some(idx) = rest.find(|c| c < '!' || c == '+' || c == '=') {
+            let (start, end) = rest.split_at(idx);
+            f.write_str(start)?;
+
+            let mut end_iter = end.char_indices();
+            let (_, c) = end_iter.next().expect("char");
+            write!(f, "+{:X}", c as u8)?;
+
+            if let Some((idx, _)) = end_iter.next() {
+                rest = &end[idx..];
+            } else {
+                rest = "";
+            }
+        }
+        f.write_str(rest)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::XText;
+
+    #[test]
+    fn test() {
+        for (input, expect) in vec![
+            ("bjorn", "bjorn"),
+            ("bjørn", "bjørn"),
+            ("Ø+= ❤️‰", "Ø+2B+3D+20❤️‰"),
+            ("+", "+2B"),
+        ] {
+            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/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/authentication.rs

@@ -1,109 +0,0 @@
-//! Provides authentication mecanisms
-
-use std::fmt::{Display, Formatter};
-use std::fmt;
-
-use serialize::base64::{self, ToBase64, FromBase64};
-use serialize::hex::ToHex;
-use crypto::hmac::Hmac;
-use crypto::md5::Md5;
-use crypto::mac::Mac;
-
-use NUL;
-use error::Error;
-
-/// Represents authentication mecanisms
-#[derive(PartialEq,Eq,Copy,Clone,Hash,Debug)]
-pub enum Mecanism {
-    /// PLAIN authentication mecanism
-    /// RFC 4616: https://tools.ietf.org/html/rfc4616
-    Plain,
-    /// CRAM-MD5 authentication mecanism
-    /// RFC 2195: https://tools.ietf.org/html/rfc2195
-    CramMd5,
-}
-
-impl Display for Mecanism {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f,
-               "{}",
-               match *self {
-                   Mecanism::Plain => "PLAIN",
-                   Mecanism::CramMd5 => "CRAM-MD5",
-               })
-    }
-}
-
-impl Mecanism {
-    /// Does the mecanism supports initial response
-    pub fn supports_initial_response(&self) -> bool {
-        match *self {
-            Mecanism::Plain => true,
-            Mecanism::CramMd5 => false,
-        }
-    }
-
-    /// Returns the string to send to the server, using the provided username, password and
-    /// challenge in some cases
-    pub fn response(&self,
-                    username: &str,
-                    password: &str,
-                    challenge: Option<&str>)
-                    -> Result<String, Error> {
-        match *self {
-            Mecanism::Plain => {
-                match challenge {
-                    Some(_) => Err(Error::ClientError("This mecanism does not expect a challenge")),
-                    None => Ok(format!("{}{}{}{}", NUL, username, NUL, password)
-                                   .as_bytes()
-                                   .to_base64(base64::STANDARD)),
-                }
-            }
-            Mecanism::CramMd5 => {
-                let encoded_challenge = match challenge {
-                    Some(challenge) => challenge,
-                    None => return Err(Error::ClientError("This mecanism does expect a challenge")),
-                };
-
-                let decoded_challenge = match encoded_challenge.from_base64() {
-                    Ok(challenge) => challenge,
-                    Err(error) => return Err(Error::ChallengeParsingError(error)),
-                };
-
-                let mut hmac = Hmac::new(Md5::new(), password.as_bytes());
-                hmac.input(&decoded_challenge);
-
-                Ok(format!("{} {}", username, hmac.result().code().to_hex())
-                       .as_bytes()
-                       .to_base64(base64::STANDARD))
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::Mecanism;
-
-    #[test]
-    fn test_plain() {
-        let mecanism = Mecanism::Plain;
-
-        assert_eq!(mecanism.response("username", "password", None).unwrap(),
-                   "AHVzZXJuYW1lAHBhc3N3b3Jk");
-        assert!(mecanism.response("username", "password", Some("test")).is_err());
-    }
-
-    #[test]
-    fn test_cram_md5() {
-        let mecanism = Mecanism::CramMd5;
-
-        assert_eq!(mecanism.response("alice",
-                                     "wonderland",
-                                     Some("PDE3ODkzLjEzMjA2NzkxMjNAdGVzc2VyYWN0LnN1c2FtLmluPg=="))
-                           .unwrap(),
-                   "YWxpY2UgNjRiMmE0M2MxZjZlZDY4MDZhOTgwOTE0ZTIzZTc1ZjA=");
-        assert!(mecanism.response("alice", "wonderland", Some("tést")).is_err());
-        assert!(mecanism.response("alice", "wonderland", None).is_err());
-    }
-}

src/client/mod.rs

@@ -1,274 +0,0 @@
-//! SMTP client
-
-use std::string::String;
-use std::net::ToSocketAddrs;
-use std::io::{BufRead, Read, Write};
-use std::io;
-use std::fmt::Debug;
-
-use bufstream::BufStream;
-use openssl::ssl::SslContext;
-
-use response::ResponseParser;
-use authentication::Mecanism;
-use error::{Error, SmtpResult};
-use client::net::{Connector, NetworkStream};
-use {CRLF, MESSAGE_ENDING};
-
-pub mod net;
-
-/// Returns the string after adding a dot at the beginning of each line starting with a dot
-///
-/// Reference : https://tools.ietf.org/html/rfc5321#page-62 (4.5.2. Transparency)
-#[inline]
-fn escape_dot(string: &str) -> String {
-    if string.starts_with(".") {
-        format!(".{}", string)
-    } else {
-        string.to_string()
-    }
-        .replace("\r.", "\r..")
-        .replace("\n.", "\n..")
-}
-
-/// Returns the string replacing all the CRLF with "\<CRLF\>"
-#[inline]
-fn escape_crlf(string: &str) -> String {
-    string.replace(CRLF, "<CR><LF>")
-}
-
-/// Returns the string removing all the CRLF
-#[inline]
-fn remove_crlf(string: &str) -> String {
-    string.replace(CRLF, "")
-}
-
-/// Structure that implements the SMTP client
-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))
-    })
-);
-
-impl<S: Write + Read = NetworkStream> 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 + Debug + Clone = NetworkStream> Client<S> {
-    /// Closes the SMTP transaction if possible
-    pub fn close(&mut self) {
-        let _ = self.quit();
-        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, ssl_context: &SslContext) -> io::Result<()> {
-        //let current_stream = self.stream.clone();
-        if self.stream.is_some() {
-            self.stream.as_mut().unwrap().get_mut().upgrade_tls(ssl_context)
-        } else {
-            Ok(())
-        }
-    }
-
-    /// Connects to the configured server
-    pub fn connect<A: ToSocketAddrs>(&mut self, addr: &A) -> 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 = try!(addr.to_socket_addrs());
-
-        let server_addr = match addresses.next() {
-            Some(addr) => addr,
-            None => return_err!("Could not resolve hostname", self),
-        };
-
-        // Try to connect
-        self.set_stream(try!(Connector::connect(&server_addr, None)));
-
-        self.get_reply()
-    }
-
-    /// Checks if the server is connected using the NOOP SMTP command
-    pub fn is_connected(&mut self) -> bool {
-        self.noop().is_ok()
-    }
-
-    /// Sends an SMTP command
-    pub fn command(&mut self, command: &str) -> SmtpResult {
-        self.send_server(command, CRLF)
-    }
-
-    /// Sends a EHLO command
-    pub fn ehlo(&mut self, hostname: &str) -> SmtpResult {
-        self.command(&format!("EHLO {}", hostname))
-    }
-
-    /// Sends a MAIL command
-    pub fn mail(&mut self, address: &str, options: Option<&str>) -> SmtpResult {
-        match options {
-            Some(ref options) => self.command(&format!("MAIL FROM:<{}> {}", address, options)),
-            None => self.command(&format!("MAIL FROM:<{}>", address)),
-        }
-    }
-
-    /// Sends a RCPT command
-    pub fn rcpt(&mut self, address: &str) -> SmtpResult {
-        self.command(&format!("RCPT TO:<{}>", address))
-    }
-
-    /// Sends a DATA command
-    pub fn data(&mut self) -> SmtpResult {
-        self.command("DATA")
-    }
-
-    /// Sends a QUIT command
-    pub fn quit(&mut self) -> SmtpResult {
-        self.command("QUIT")
-    }
-
-    /// Sends a NOOP command
-    pub fn noop(&mut self) -> SmtpResult {
-        self.command("NOOP")
-    }
-
-    /// Sends a HELP command
-    pub fn help(&mut self, argument: Option<&str>) -> SmtpResult {
-        match argument {
-            Some(ref argument) => self.command(&format!("HELP {}", argument)),
-            None => self.command("HELP"),
-        }
-    }
-
-    /// Sends a VRFY command
-    pub fn vrfy(&mut self, address: &str) -> SmtpResult {
-        self.command(&format!("VRFY {}", address))
-    }
-
-    /// Sends a EXPN command
-    pub fn expn(&mut self, address: &str) -> SmtpResult {
-        self.command(&format!("EXPN {}", address))
-    }
-
-    /// Sends a RSET command
-    pub fn rset(&mut self) -> SmtpResult {
-        self.command("RSET")
-    }
-
-    /// Sends an AUTH command with the given mecanism
-    pub fn auth(&mut self, mecanism: Mecanism, username: &str, password: &str) -> SmtpResult {
-
-        if mecanism.supports_initial_response() {
-            self.command(&format!("AUTH {} {}",
-                                  mecanism,
-                                  try!(mecanism.response(username, password, None))))
-        } else {
-            let encoded_challenge = match try!(self.command("AUTH CRAM-MD5")).first_word() {
-                Some(challenge) => challenge,
-                None => return Err(Error::ResponseParsingError("Could not read CRAM challenge")),
-            };
-
-            debug!("CRAM challenge: {}", encoded_challenge);
-
-            let cram_response = try!(mecanism.response(username,
-                                                       password,
-                                                       Some(&encoded_challenge)));
-
-            self.command(&format!("{}", cram_response))
-        }
-    }
-
-    /// Sends a STARTTLS command
-    pub fn starttls(&mut self) -> SmtpResult {
-        self.command("STARTTLS")
-    }
-
-    /// Sends the message content
-    pub fn message(&mut self, message_content: &str) -> SmtpResult {
-        self.send_server(&escape_dot(message_content), MESSAGE_ENDING)
-    }
-
-    /// Sends a string to the server and gets the response
-    fn send_server(&mut self, string: &str, end: &str) -> SmtpResult {
-        if self.stream.is_none() {
-            return Err(From::from("Connection closed"));
-        }
-
-        try!(write!(self.stream.as_mut().unwrap(), "{}{}", string, end));
-        try!(self.stream.as_mut().unwrap().flush());
-
-        debug!("Wrote: {}", escape_crlf(string));
-
-        self.get_reply()
-    }
-
-    /// Gets the SMTP response
-    fn get_reply(&mut self) -> SmtpResult {
-
-        let mut parser = ResponseParser::new();
-
-        let mut line = String::new();
-        try!(self.stream.as_mut().unwrap().read_line(&mut line));
-
-        debug!("Read: {}", escape_crlf(line.as_ref()));
-
-        while try!(parser.read_line(remove_crlf(line.as_ref()).as_ref())) {
-            line.clear();
-            try!(self.stream.as_mut().unwrap().read_line(&mut line));
-        }
-
-        let response = try!(parser.response());
-
-        match response.is_positive() {
-            true => Ok(response),
-            false => Err(From::from(response)),
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::{escape_dot, remove_crlf, escape_crlf};
-
-    #[test]
-    fn test_escape_dot() {
-        assert_eq!(escape_dot(".test"), "..test");
-        assert_eq!(escape_dot("\r.\n.\r\n"), "\r..\n..\r\n");
-        assert_eq!(escape_dot("test\r\n.test\r\n"), "test\r\n..test\r\n");
-        assert_eq!(escape_dot("test\r\n.\r\ntest"), "test\r\n..\r\ntest");
-    }
-
-    #[test]
-    fn test_remove_crlf() {
-        assert_eq!(remove_crlf("\r\n"), "");
-        assert_eq!(remove_crlf("EHLO my_name\r\n"), "EHLO my_name");
-        assert_eq!(remove_crlf("EHLO my_name\r\nSIZE 42\r\n"),
-                   "EHLO my_nameSIZE 42");
-    }
-
-    #[test]
-    fn test_escape_crlf() {
-        assert_eq!(escape_crlf("\r\n"), "<CR><LF>");
-        assert_eq!(escape_crlf("EHLO my_name\r\n"), "EHLO my_name<CR><LF>");
-        assert_eq!(escape_crlf("EHLO my_name\r\nSIZE 42\r\n"),
-                   "EHLO my_name<CR><LF>SIZE 42<CR><LF>");
-    }
-}

src/client/net.rs

@@ -1,94 +0,0 @@
-//! A trait to represent a stream
-
-use std::io;
-use std::io::{Read, Write, ErrorKind};
-use std::net::SocketAddr;
-use std::net::TcpStream;
-use std::fmt;
-use std::fmt::{Debug, Formatter};
-use openssl::ssl::{SslContext, SslStream};
-
-/// A trait for the concept of opening a stream
-pub trait Connector {
-    /// Opens a connection to the given IP socket
-    fn connect(addr: &SocketAddr, ssl_context: Option<&SslContext>) -> io::Result<Self>;
-    /// Upgrades to TLS connection
-    fn upgrade_tls(&mut self, ssl_context: &SslContext) -> io::Result<()>;
-}
-
-impl Connector for NetworkStream {
-    fn connect(addr: &SocketAddr, ssl_context: Option<&SslContext>) -> io::Result<NetworkStream> {
-        let tcp_stream = try!(TcpStream::connect(addr));
-
-        match ssl_context {
-            Some(context) => match SslStream::new(&context, tcp_stream) {
-                Ok(stream) => Ok(NetworkStream::Ssl(stream)),
-                Err(err) => Err(io::Error::new(ErrorKind::Other, err)),
-            },
-            None => Ok(NetworkStream::Plain(tcp_stream)),
-        }
-    }
-
-    fn upgrade_tls(&mut self, ssl_context: &SslContext) -> io::Result<()> {
-        *self = match self.clone() {
-            NetworkStream::Plain(stream) => match SslStream::new(ssl_context, stream) {
-                Ok(ssl_stream) => NetworkStream::Ssl(ssl_stream),
-                Err(err) => return Err(io::Error::new(ErrorKind::Other, err)),
-            },
-            NetworkStream::Ssl(stream) => NetworkStream::Ssl(stream),
-        };
-        Ok(())
-    }
-}
-
-
-/// Represents the different types of underlying network streams
-pub enum NetworkStream {
-    /// Plain TCP
-    Plain(TcpStream),
-    /// SSL over TCP
-    Ssl(SslStream<TcpStream>),
-}
-
-impl Clone for NetworkStream {
-    #[inline]
-    fn clone(&self) -> NetworkStream {
-        match self {
-            &NetworkStream::Plain(ref stream) => NetworkStream::Plain(stream.try_clone().unwrap()),
-            &NetworkStream::Ssl(ref stream) => NetworkStream::Ssl(stream.try_clone().unwrap()),
-        }
-    }
-}
-
-impl Debug for NetworkStream {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        f.write_str("NetworkStream(_)")
-    }
-}
-
-impl Read for NetworkStream {
-    #[inline]
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        match *self {
-            NetworkStream::Plain(ref mut stream) => stream.read(buf),
-            NetworkStream::Ssl(ref mut stream) => stream.read(buf),
-        }
-    }
-}
-
-impl Write for NetworkStream {
-    #[inline]
-    fn write(&mut self, msg: &[u8]) -> io::Result<usize> {
-        match *self {
-            NetworkStream::Plain(ref mut stream) => stream.write(msg),
-            NetworkStream::Ssl(ref mut stream) => stream.write(msg),
-        }
-    }
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        match *self {
-            NetworkStream::Plain(ref mut stream) => stream.flush(),
-            NetworkStream::Ssl(ref mut stream) => stream.flush(),
-        }
-    }
-}

src/email.rs

@@ -1,348 +0,0 @@
-//! Simple email (very incomplete)
-
-use std::fmt::{Display, Formatter, Result};
-
-use email_format::{MimeMessage, Header, Mailbox};
-use time::{now, Tm};
-use uuid::Uuid;
-
-/// Converts an adress or an address with an alias to a `Address`
-pub trait ToHeader {
-    /// Converts to a `Header` struct
-    fn to_header(&self) -> Header;
-}
-
-impl ToHeader for Header {
-    fn to_header(&self) -> Header {
-        (*self).clone()
-    }
-}
-
-impl<'a> ToHeader for (&'a str, &'a str) {
-    fn to_header(&self) -> Header {
-        let (name, value) = *self;
-        Header::new(name.to_string(), value.to_string())
-    }
-}
-
-/// Converts an adress or an address with an alias to a `Mailbox`
-pub trait ToMailbox {
-    /// Converts to a `Mailbox` struct
-    fn to_mailbox(&self) -> Mailbox;
-}
-
-impl ToMailbox for Mailbox {
-    fn to_mailbox(&self) -> Mailbox {
-        (*self).clone()
-    }
-}
-
-impl<'a> ToMailbox for &'a str {
-    fn to_mailbox(&self) -> Mailbox {
-        Mailbox::new(self.to_string())
-    }
-}
-
-impl<'a> ToMailbox for (&'a str, &'a str) {
-    fn to_mailbox(&self) -> Mailbox {
-        let (address, alias) = *self;
-        Mailbox::new_with_name(alias.to_string(), address.to_string())
-    }
-}
-
-/// Builds an `Email` structure
-#[derive(PartialEq,Eq,Clone,Debug)]
-pub struct EmailBuilder {
-    /// Email content
-    content: Email,
-    /// Date issued
-    date_issued: bool,
-}
-
-/// Simple email representation
-#[derive(PartialEq,Eq,Clone,Debug)]
-pub struct Email {
-    /// Message
-    message: MimeMessage,
-    /// The enveloppe recipients addresses
-    to: Vec<String>,
-    /// The enveloppe sender address
-    from: Option<String>,
-    /// Message-ID
-    message_id: Uuid,
-}
-
-impl Display for Email {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        write!(f, "{}", self.message.as_string())
-    }
-}
-
-impl EmailBuilder {
-    /// Creates a new empty email
-    pub fn new() -> EmailBuilder {
-        let current_message = Uuid::new_v4();
-
-        let mut email = Email {
-            message: MimeMessage::new_blank_message(),
-            to: vec![],
-            from: None,
-            message_id: current_message,
-        };
-
-        match Header::new_with_value("Message-ID".to_string(),
-                                     format!("<{}@rust-smtp>", current_message)) {
-            Ok(header) => email.message.headers.insert(header),
-            Err(_) => (),
-        }
-
-        EmailBuilder {
-            content: email,
-            date_issued: false,
-        }
-    }
-
-    /// Sets the email body
-    pub fn body(mut self, body: &str) -> EmailBuilder {
-        self.content.message.body = body.to_string();
-        self
-    }
-
-    /// Add a generic header
-    pub fn add_header<A: ToHeader>(mut self, header: A) -> EmailBuilder {
-        self.insert_header(header);
-        self
-    }
-
-    fn insert_header<A: ToHeader>(&mut self, header: A) {
-        self.content.message.headers.insert(header.to_header());
-    }
-
-    /// Adds a `From` header and store the sender address
-    pub fn from<A: ToMailbox>(mut self, address: A) -> EmailBuilder {
-        let mailbox = address.to_mailbox();
-        self.insert_header(("From", mailbox.to_string().as_ref()));
-        self.content.from = Some(mailbox.address);
-        self
-    }
-
-    /// Adds a `To` header and store the recipient address
-    pub fn to<A: ToMailbox>(mut self, address: A) -> EmailBuilder {
-        let mailbox = address.to_mailbox();
-        self.insert_header(("To", mailbox.to_string().as_ref()));
-        self.content.to.push(mailbox.address);
-        self
-    }
-
-    /// Adds a `Cc` header and store the recipient address
-    pub fn cc<A: ToMailbox>(mut self, address: A) -> EmailBuilder {
-        let mailbox = address.to_mailbox();
-        self.insert_header(("Cc", mailbox.to_string().as_ref()));
-        self.content.to.push(mailbox.address);
-        self
-    }
-
-    /// Adds a `Reply-To` header
-    pub fn reply_to<A: ToMailbox>(mut self, address: A) -> EmailBuilder {
-        let mailbox = address.to_mailbox();
-        self.insert_header(("Reply-To", mailbox.to_string().as_ref()));
-        self
-    }
-
-    /// Adds a `Sender` header
-    pub fn sender<A: ToMailbox>(mut self, address: A) -> EmailBuilder {
-        let mailbox = address.to_mailbox();
-        self.insert_header(("Sender", mailbox.to_string().as_ref()));
-        self.content.from = Some(mailbox.address);
-        self
-    }
-
-    /// Adds a `Subject` header
-    pub fn subject(mut self, subject: &str) -> EmailBuilder {
-        self.insert_header(("Subject", subject));
-        self
-    }
-
-    /// Adds a `Date` header with the given date
-    pub fn date(mut self, date: &Tm) -> EmailBuilder {
-        self.insert_header(("Date", Tm::rfc822z(date).to_string().as_ref()));
-        self.date_issued = true;
-        self
-    }
-
-    /// Build the Email
-    pub fn build(mut self) -> Email {
-        if !self.date_issued {
-            self.insert_header(("Date", Tm::rfc822z(&now()).to_string().as_ref()));
-        }
-        self.content.message.update_headers();
-        self.content
-    }
-}
-
-
-/// Email sendable by an SMTP client
-pub trait SendableEmail {
-    /// From address
-    fn from_address(&self) -> Option<String>;
-    /// To addresses
-    fn to_addresses(&self) -> Option<Vec<String>>;
-    /// Message content
-    fn message(&self) -> Option<String>;
-    /// Message ID
-    fn message_id(&self) -> Option<String>;
-}
-
-/// Minimal email structure
-pub struct SimpleSendableEmail {
-    /// From address
-    from: String,
-    /// To addresses
-    to: Vec<String>,
-    /// Message
-    message: String,
-}
-
-impl SimpleSendableEmail {
-    /// Returns a new email
-    pub fn new(from_address: &str, to_address: &str, message: &str) -> SimpleSendableEmail {
-        SimpleSendableEmail {
-            from: from_address.to_string(),
-            to: vec![to_address.to_string()],
-            message: message.to_string(),
-        }
-    }
-}
-
-impl SendableEmail for SimpleSendableEmail {
-    fn from_address(&self) -> Option<String> {
-        Some(self.from.clone())
-    }
-
-    fn to_addresses(&self) -> Option<Vec<String>> {
-        Some(self.to.clone())
-    }
-
-    fn message(&self) -> Option<String> {
-        Some(self.message.clone())
-    }
-
-    fn message_id(&self) -> Option<String> {
-        Some(format!("<{}@rust-smtp>", Uuid::new_v4()))
-    }
-}
-
-impl SendableEmail for Email {
-    /// Return the to addresses, and fails if it is not set
-    fn to_addresses(&self) -> Option<Vec<String>> {
-        if self.to.is_empty() {
-            None
-        } else {
-            Some(self.to.clone())
-        }
-    }
-
-    /// Return the from address, and fails if it is not set
-    fn from_address(&self) -> Option<String> {
-        match self.from {
-            Some(ref from_address) => Some(from_address.clone()),
-            None => None,
-        }
-    }
-
-    fn message(&self) -> Option<String> {
-        Some(format!("{}", self))
-    }
-
-    fn message_id(&self) -> Option<String> {
-        Some(format!("{}", self.message_id))
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use time::now;
-
-    use uuid::Uuid;
-    use email_format::{MimeMessage, Header};
-
-    use super::{SendableEmail, EmailBuilder, Email};
-
-    #[test]
-    fn test_email_display() {
-        let current_message = Uuid::new_v4();
-
-        let mut email = Email {
-            message: MimeMessage::new_blank_message(),
-            to: vec![],
-            from: None,
-            message_id: current_message,
-        };
-
-        email.message.headers.insert(Header::new_with_value("Message-ID".to_string(),
-                                                            format!("<{}@rust-smtp>",
-                                                                    current_message))
-                                         .unwrap());
-
-        email.message
-             .headers
-             .insert(Header::new_with_value("To".to_string(), "to@example.com".to_string())
-                         .unwrap());
-
-        email.message.body = "body".to_string();
-
-        assert_eq!(format!("{}", email),
-                   format!("Message-ID: <{}@rust-smtp>\r\nTo: to@example.com\r\n\r\nbody\r\n",
-                           current_message));
-        assert_eq!(current_message.to_string(), email.message_id().unwrap());
-    }
-
-    #[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"))
-                                 .reply_to("reply@localhost")
-                                 .sender("sender@localhost")
-                                 .body("Hello World!")
-                                 .date(&date_now)
-                                 .subject("Hello")
-                                 .add_header(("X-test", "value"))
-                                 .build();
-
-        assert_eq!(format!("{}", email),
-                   format!("Message-ID: <{}@rust-smtp>\r\nTo: <user@localhost>\r\nFrom: \
-                            <user@localhost>\r\nCc: \"Alias\" <cc@localhost>\r\nReply-To: \
-                            <reply@localhost>\r\nSender: <sender@localhost>\r\nDate: \
-                            {}\r\nSubject: Hello\r\nX-test: value\r\n\r\nHello World!\r\n",
-                           email.message_id().unwrap(),
-                           date_now.rfc822z()));
-    }
-
-    #[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"))
-                                 .reply_to("reply@localhost")
-                                 .sender("sender@localhost")
-                                 .body("Hello World!")
-                                 .date(&date_now)
-                                 .subject("Hello")
-                                 .add_header(("X-test", "value"))
-                                 .build();
-
-        assert_eq!(email.from_address().unwrap(),
-                   "sender@localhost".to_string());
-        assert_eq!(email.to_addresses().unwrap(),
-                   vec!["user@localhost".to_string(), "cc@localhost".to_string()]);
-        assert_eq!(email.message().unwrap(), format!("{}", email));
-    }
-
-}

src/error.rs

@@ -1,90 +0,0 @@
-//! Error and result type for SMTP clients
-
-use std::error::Error as StdError;
-use std::io;
-use std::fmt::{Display, Formatter};
-use std::fmt;
-
-use response::{Severity, Response};
-use serialize::base64::FromBase64Error;
-use self::Error::*;
-
-/// 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)
-    TransientError(Response),
-    /// Permanent SMTP error, 5xx reply code
-    ///
-    /// [RFC 5321, section 4.2.1](https://tools.ietf.org/html/rfc5321#section-4.2.1)
-    PermanentError(Response),
-    /// Error parsing a response
-    ResponseParsingError(&'static str),
-    /// Error parsing a base64 string in response
-    ChallengeParsingError(FromBase64Error),
-    /// Internal client error
-    ClientError(&'static str),
-    /// DNS resolution error
-    ResolutionError,
-    /// IO error
-    IoError(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 {
-            TransientError(_) => "a transient error occured during the SMTP transaction",
-            PermanentError(_) => "a permanent error occured during the SMTP transaction",
-            ResponseParsingError(_) => "an error occured while parsing an SMTP response",
-            ChallengeParsingError(_) => "an error occured while parsing a CRAM-MD5 challenge",
-            ResolutionError => "Could no resolve hostname",
-            ClientError(_) => "an unknown error occured",
-            IoError(_) => "an I/O error occured",
-        }
-    }
-
-    fn cause(&self) -> Option<&StdError> {
-        match *self {
-            IoError(ref err) => Some(&*err as &StdError),
-            _ => None,
-        }
-    }
-}
-
-impl From<io::Error> for Error {
-    fn from(err: io::Error) -> Error {
-        IoError(err)
-    }
-}
-
-impl From<Response> for Error {
-    fn from(response: Response) -> Error {
-        match response.severity() {
-            Severity::TransientNegativeCompletion => TransientError(response),
-            Severity::PermanentNegativeCompletion => PermanentError(response),
-            _ => ClientError("Unknown error code"),
-        }
-    }
-}
-
-impl From<&'static str> for Error {
-    fn from(string: &'static str) -> Error {
-        ClientError(string)
-    }
-}
-
-/// SMTP result type
-pub type SmtpResult = Result<Response, Error>;
-
-#[cfg(test)]
-mod test {
-    // TODO
-}

src/extension.rs

@@ -1,220 +0,0 @@
-//! ESMTP features
-
-use std::result::Result;
-use std::fmt::{Display, Formatter};
-use std::fmt;
-use std::collections::HashSet;
-
-use response::Response;
-use error::Error;
-use authentication::Mecanism;
-
-/// Supported ESMTP keywords
-#[derive(PartialEq,Eq,Hash,Clone,Debug)]
-pub enum Extension {
-    /// 8BITMIME keyword
-    ///
-    /// RFC 6152: https://tools.ietf.org/html/rfc6152
-    EightBitMime,
-    /// SMTPUTF8 keyword
-    ///
-    /// RFC 6531: https://tools.ietf.org/html/rfc6531
-    SmtpUtfEight,
-    /// STARTTLS keyword
-    ///
-    /// RFC 2487: https://tools.ietf.org/html/rfc2487
-    StartTls,
-    /// AUTH mecanism
-    Authentication(Mecanism),
-}
-
-impl Display for Extension {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        match *self {
-            Extension::EightBitMime => write!(f, "{}", "8BITMIME"),
-            Extension::SmtpUtfEight => write!(f, "{}", "SMTPUTF8"),
-            Extension::StartTls => write!(f, "{}", "STARTTLS"),
-            Extension::Authentication(ref mecanism) => write!(f, "{} {}", "AUTH", mecanism),
-        }
-    }
-}
-
-/// Contains information about an SMTP server
-#[derive(Clone,Debug,Eq,PartialEq)]
-pub struct ServerInfo {
-    /// Server name
-    ///
-    /// The name given in the server banner
-    pub name: String,
-    /// ESMTP features supported by the server
-    ///
-    /// It contains the features supported by the server and known by the `Extension` module.
-    pub features: HashSet<Extension>,
-}
-
-impl Display for ServerInfo {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f,
-               "{} with {}",
-               self.name,
-               match self.features.is_empty() {
-                   true => "no supported features".to_string(),
-                   false => format!("{:?}", self.features),
-               })
-    }
-}
-
-impl ServerInfo {
-    /// Parses a response to create a `ServerInfo`
-    pub fn from_response(response: &Response) -> Result<ServerInfo, Error> {
-        let name = match response.first_word() {
-            Some(name) => name,
-            None => return Err(Error::ResponseParsingError("Could not read server name")),
-        };
-
-        let mut features: HashSet<Extension> = HashSet::new();
-
-        for line in response.message() {
-
-            let splitted: Vec<&str> = line.split_whitespace().collect();
-            let _ = match splitted[0] {
-                "8BITMIME" => {
-                    features.insert(Extension::EightBitMime);
-                }
-                "SMTPUTF8" => {
-                    features.insert(Extension::SmtpUtfEight);
-                }
-                "STARTTLS" => {
-                    features.insert(Extension::StartTls);
-                }
-                "AUTH" => {
-                    for &mecanism in &splitted[1..] {
-                        match mecanism {
-                            "PLAIN" => {
-                                features.insert(Extension::Authentication(Mecanism::Plain));
-                            }
-                            "CRAM-MD5" => {
-                                features.insert(Extension::Authentication(Mecanism::CramMd5));
-                            }
-                            _ => (),
-                        }
-                    }
-                }
-                _ => (),
-            };
-        }
-
-        Ok(ServerInfo {
-            name: name,
-            features: features,
-        })
-    }
-
-    /// Checks if the server supports an ESMTP feature
-    pub fn supports_feature(&self, keyword: &Extension) -> bool {
-        self.features.contains(keyword)
-    }
-
-    /// Checks if the server supports an ESMTP feature
-    pub fn supports_auth_mecanism(&self, mecanism: Mecanism) -> bool {
-        self.features.contains(&Extension::Authentication(mecanism))
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::collections::HashSet;
-
-    use super::{ServerInfo, Extension};
-    use authentication::Mecanism;
-    use response::{Code, Response, Severity, Category};
-
-    #[test]
-    fn test_extension_fmt() {
-        assert_eq!(format!("{}", Extension::EightBitMime),
-                   "8BITMIME".to_string());
-        assert_eq!(format!("{}", Extension::Authentication(Mecanism::Plain)),
-                   "AUTH PLAIN".to_string());
-    }
-
-    #[test]
-    fn test_serverinfo_fmt() {
-        let mut eightbitmime = HashSet::new();
-        assert!(eightbitmime.insert(Extension::EightBitMime));
-
-        assert_eq!(format!("{}",
-                           ServerInfo {
-                               name: "name".to_string(),
-                               features: eightbitmime.clone(),
-                           }),
-                   "name with {EightBitMime}".to_string());
-
-        let empty = HashSet::new();
-
-        assert_eq!(format!("{}",
-                           ServerInfo {
-                               name: "name".to_string(),
-                               features: empty,
-                           }),
-                   "name with no supported features".to_string());
-
-        let mut plain = HashSet::new();
-        assert!(plain.insert(Extension::Authentication(Mecanism::Plain)));
-
-        assert_eq!(format!("{}",
-                           ServerInfo {
-                               name: "name".to_string(),
-                               features: plain.clone(),
-                           }),
-                   "name with {Authentication(Plain)}".to_string());
-    }
-
-    #[test]
-    fn test_serverinfo() {
-        let response = Response::new(Code::new(Severity::PositiveCompletion,
-                                               Category::Unspecified4,
-                                               1),
-                                     vec!["me".to_string(),
-                                          "8BITMIME".to_string(),
-                                          "SIZE 42".to_string()]);
-
-        let mut features = HashSet::new();
-        assert!(features.insert(Extension::EightBitMime));
-
-        let server_info = ServerInfo {
-            name: "me".to_string(),
-            features: features,
-        };
-
-        assert_eq!(ServerInfo::from_response(&response).unwrap(), server_info);
-
-        assert!(server_info.supports_feature(&Extension::EightBitMime));
-        assert!(!server_info.supports_feature(&Extension::StartTls));
-        assert!(!server_info.supports_auth_mecanism(Mecanism::CramMd5));
-
-        let response2 = Response::new(Code::new(Severity::PositiveCompletion,
-                                                Category::Unspecified4,
-                                                1),
-                                      vec!["me".to_string(),
-                                           "AUTH PLAIN CRAM-MD5 OTHER".to_string(),
-                                           "8BITMIME".to_string(),
-                                           "SIZE 42".to_string()]);
-
-        let mut features2 = HashSet::new();
-        assert!(features2.insert(Extension::EightBitMime));
-        assert!(features2.insert(Extension::Authentication(Mecanism::Plain)));
-        assert!(features2.insert(Extension::Authentication(Mecanism::CramMd5)));
-
-        let server_info2 = ServerInfo {
-            name: "me".to_string(),
-            features: features2,
-        };
-
-        assert_eq!(ServerInfo::from_response(&response2).unwrap(), server_info2);
-
-        assert!(server_info2.supports_feature(&Extension::EightBitMime));
-        assert!(server_info2.supports_auth_mecanism(Mecanism::Plain));
-        assert!(server_info2.supports_auth_mecanism(Mecanism::CramMd5));
-        assert!(!server_info2.supports_feature(&Extension::StartTls));
-    }
-}

src/lib.rs

@@ -1,186 +0,0 @@
-//! # Rust SMTP client
-//!
-//! This client should tend to follow [RFC 5321](https://tools.ietf.org/html/rfc5321), but is still
-//! a work in progress. It 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 and CRAM-MD5 mecanisms
-//! * STARTTLS ([RFC 2487](http://tools.ietf.org/html/rfc2487))
-//!
-//! It will eventually implement the following extensions:
-//!
-//! * SMTPUTF8 ([RFC 6531](http://tools.ietf.org/html/rfc6531))
-//!
-//! ## Architecture
-//!
-//! This client is divided into three main parts:
-//!
-//! * client: a low level SMTP client providing all SMTP commands
-//! * sender: a high level SMTP client providing an easy method to send emails
-//! * email: generates the email to be sent with the sender
-//!
-//! ## Usage
-//!
-//! ### Simple example
-//!
-//! This is the most basic example of usage:
-//!
-//! ```rust,no_run
-//! use smtp::sender::{Sender, SenderBuilder};
-//! use smtp::email::EmailBuilder;
-//!
-//! // Create an email
-//! let email = EmailBuilder::new()
-//!     // Addresses can be specified by the couple (email, alias)
-//!     .to(("user@example.org", "Firstname Lastname"))
-//!     // ... or by an address only
-//!     .from("user@example.com")
-//!     .subject("Hi, Hello world")
-//!     .body("Hello world.")
-//!     .build();
-//!
-//! // Open a local connection on port 25
-//! let mut sender = SenderBuilder::localhost().unwrap().build();
-//! // Send the email
-//! let result = sender.send(email);
-//!
-//! assert!(result.is_ok());
-//! ```
-//!
-//! ### Complete example
-//!
-//! ```rust,no_run
-//! use smtp::sender::{Sender, SenderBuilder};
-//! use smtp::email::EmailBuilder;
-//! use smtp::authentication::Mecanism;
-//! use smtp::SUBMISSION_PORT;
-//!
-//! let mut builder = EmailBuilder::new();
-//! builder = builder.to(("user@example.org", "Alias name"));
-//! builder = builder.cc(("user@example.net", "Alias name"));
-//! builder = builder.from("no-reply@example.com");
-//! builder = builder.from("no-reply@example.eu");
-//! builder = builder.sender("no-reply@example.com");
-//! builder = builder.subject("Hello world");
-//! builder = builder.body("Hi, Hello world.");
-//! builder = builder.reply_to("contact@example.com");
-//! builder = builder.add_header(("X-Custom-Header", "my header"));
-//!
-//! let email = builder.build();
-//!
-//! // Connect to a remote server on a custom port
-//! let mut sender = SenderBuilder::new(("server.tld", SUBMISSION_PORT)).unwrap()
-//!     // Set the name sent during EHLO/HELO, default is `localhost`
-//!     .hello_name("my.hostname.tld")
-//!     // Add credentials for authentication
-//!     .credentials("username", "password")
-//!     // Use TLS with STARTTLS, you can also specify a specific SSL context
-//!     // with `.ssl_context(context)`
-//!     .starttls()
-//!     // Configure accepted authetication mecanisms
-//!     .authentication_mecanisms(vec![Mecanism::CramMd5])
-//!     // Enable connection reuse
-//!     .enable_connection_reuse(true).build();
-//!
-//! let result_1 = sender.send(email.clone());
-//! assert!(result_1.is_ok());
-//!
-//! // The second email will use the same connection
-//! let result_2 = sender.send(email);
-//! assert!(result_2.is_ok());
-//!
-//! // Explicitely close the SMTP transaction as we enabled connection reuse
-//! sender.close();
-//! ```
-//!
-//! ### Using the client directly
-//!
-//! If you just want to send an email without using `Email` to provide headers:
-//!
-//! ```rust,no_run
-//! use smtp::sender::{Sender, SenderBuilder};
-//! use smtp::email::SimpleSendableEmail;
-//!
-//! // Create a minimal email
-//! let email = SimpleSendableEmail::new(
-//!     "test@example.com",
-//!     "test@example.org",
-//!     "Hello world !"
-//! );
-//!
-//! let mut sender = SenderBuilder::localhost().unwrap().build();
-//! let result = sender.send(email);
-//! assert!(result.is_ok());
-//! ```
-//!
-//! ### Lower level
-//!
-//! You can also send commands, here is a simple email transaction without error handling:
-//!
-//! ```rust,no_run
-//! use smtp::client::Client;
-//! use smtp::SMTP_PORT;
-//! use smtp::client::net::NetworkStream;
-//!
-//! let mut email_client: Client<NetworkStream> = Client::new();
-//! let _ = email_client.connect(&("localhost", SMTP_PORT));
-//! let _ = email_client.ehlo("my_hostname");
-//! let _ = email_client.mail("user@example.com", None);
-//! let _ = email_client.rcpt("user@example.org");
-//! let _ = email_client.data();
-//! let _ = email_client.message("Test email");
-//! let _ = email_client.quit();
-//! ```
-
-#![deny(missing_docs)]
-
-#[macro_use]
-extern crate log;
-extern crate rustc_serialize as serialize;
-extern crate crypto;
-extern crate time;
-extern crate uuid;
-extern crate email as email_format;
-extern crate bufstream;
-extern crate openssl;
-
-mod extension;
-pub mod client;
-pub mod sender;
-pub mod response;
-pub mod error;
-pub mod authentication;
-pub mod email;
-
-// Registrated port numbers:
-// https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml
-
-/// Default smtp port
-pub static SMTP_PORT: u16 = 25;
-
-/// Default smtps port
-pub static SMTPS_PORT: u16 = 465;
-
-/// Default submission port
-pub static SUBMISSION_PORT: u16 = 587;
-
-// Useful strings and characters
-
-/// The word separator for SMTP transactions
-pub static SP: &'static str = " ";
-
-/// The line ending for SMTP transactions (carriage return + line feed)
-pub static CRLF: &'static str = "\r\n";
-
-/// Colon
-pub static COLON: &'static str = ":";
-
-/// The ending of message content
-pub static MESSAGE_ENDING: &'static str = "\r\n.\r\n";
-
-/// NUL unicode character
-pub static NUL: &'static str = "\0";

src/response.rs

@@ -1,588 +0,0 @@
-//! SMTP response, containing a mandatory return code and an optional text message
-
-use std::str::FromStr;
-use std::fmt::{Display, Formatter, Result};
-use std::result;
-
-use self::Severity::*;
-use self::Category::*;
-use error::{SmtpResult, Error};
-
-/// First digit indicates severity
-#[derive(PartialEq,Eq,Copy,Clone,Debug)]
-pub enum Severity {
-    /// 2yx
-    PositiveCompletion,
-    /// 3yz
-    PositiveIntermediate,
-    /// 4yz
-    TransientNegativeCompletion,
-    /// 5yz
-    PermanentNegativeCompletion,
-}
-
-impl FromStr for Severity {
-    type Err = Error;
-    fn from_str(s: &str) -> result::Result<Severity, Error> {
-        match s {
-            "2" => Ok(PositiveCompletion),
-            "3" => Ok(PositiveIntermediate),
-            "4" => Ok(TransientNegativeCompletion),
-            "5" => Ok(PermanentNegativeCompletion),
-            _ => Err(Error::ResponseParsingError("First digit must be between 2 and 5")),
-        }
-    }
-}
-
-impl Display for Severity {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        write!(f,
-               "{}",
-               match *self {
-                   PositiveCompletion => 2,
-                   PositiveIntermediate => 3,
-                   TransientNegativeCompletion => 4,
-                   PermanentNegativeCompletion => 5,
-               })
-    }
-}
-
-/// Second digit
-#[derive(PartialEq,Eq,Copy,Clone,Debug)]
-pub enum Category {
-    /// x0z
-    Syntax,
-    /// x1z
-    Information,
-    /// x2z
-    Connections,
-    /// x3z
-    Unspecified3,
-    /// x4z
-    Unspecified4,
-    /// x5z
-    MailSystem,
-}
-
-impl FromStr for Category {
-    type Err = Error;
-    fn from_str(s: &str) -> result::Result<Category, Error> {
-        match s {
-            "0" => Ok(Syntax),
-            "1" => Ok(Information),
-            "2" => Ok(Connections),
-            "3" => Ok(Unspecified3),
-            "4" => Ok(Unspecified4),
-            "5" => Ok(MailSystem),
-            _ => Err(Error::ResponseParsingError("Second digit must be between 0 and 5")),
-        }
-    }
-}
-
-impl Display for Category {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        write!(f,
-               "{}",
-               match *self {
-                   Syntax => 0,
-                   Information => 1,
-                   Connections => 2,
-                   Unspecified3 => 3,
-                   Unspecified4 => 4,
-                   MailSystem => 5,
-               })
-    }
-}
-
-/// Represents a 3 digit SMTP response code
-#[derive(PartialEq,Eq,Clone,Debug)]
-pub struct Code {
-    /// First digit of the response code
-    severity: Severity,
-    /// Second digit of the response code
-    category: Category,
-    /// Third digit
-    detail: u8,
-}
-
-impl FromStr for Code {
-    type Err = Error;
-
-    #[inline]
-    fn from_str(s: &str) -> result::Result<Code, Error> {
-        if s.len() == 3 {
-            match (s[0..1].parse::<Severity>(),
-                   s[1..2].parse::<Category>(),
-                   s[2..3].parse::<u8>()) {
-                (Ok(severity), Ok(category), Ok(detail)) => Ok(Code {
-                    severity: severity,
-                    category: category,
-                    detail: detail,
-                }),
-                _ => return Err(Error::ResponseParsingError("Could not parse response code")),
-            }
-        } else {
-            Err(Error::ResponseParsingError("Wrong code length (should be 3 digit)"))
-        }
-    }
-}
-
-impl Code {
-    /// Creates a new `Code` structure
-    pub fn new(severity: Severity, category: Category, detail: u8) -> Code {
-        Code {
-            severity: severity,
-            category: category,
-            detail: detail,
-        }
-    }
-
-    /// Returns the reply code
-    pub fn code(&self) -> String {
-        format!("{}{}{}", self.severity, self.category, self.detail)
-    }
-}
-
-/// Parses an SMTP response
-#[derive(PartialEq,Eq,Clone,Debug)]
-pub struct ResponseParser {
-    /// Response code
-    code: Option<Code>,
-    /// Server response string (optional)
-    /// Handle multiline responses
-    message: Vec<String>,
-}
-
-impl ResponseParser {
-    /// Creates a new parser
-    pub fn new() -> ResponseParser {
-        ResponseParser {
-            code: None,
-            message: vec![],
-        }
-    }
-
-    /// Parses a line and return a `bool` indicating if there are more lines to come
-    pub fn read_line(&mut self, line: &str) -> result::Result<bool, Error> {
-
-        if line.len() < 3 {
-            return Err(Error::ResponseParsingError("Wrong code length (should be 3 digit)"));
-        }
-
-        match self.code {
-            Some(ref code) => {
-                if code.code() != line[0..3] {
-                    return Err(Error::ResponseParsingError("Response code has changed during a \
-                                                            reponse"));
-                }
-            }
-            None => self.code = Some(try!(line[0..3].parse::<Code>())),
-        }
-
-        if line.len() > 4 {
-            self.message.push(line[4..].to_string());
-            if line.as_bytes()[3] == '-' as u8 {
-                Ok(true)
-            } else {
-                Ok(false)
-            }
-        } else {
-            Ok(false)
-        }
-    }
-
-    /// Builds a response from a `ResponseParser`
-    pub fn response(self) -> SmtpResult {
-        match self.code {
-            Some(code) => Ok(Response::new(code, self.message)),
-            None => Err(Error::ResponseParsingError("Incomplete response, could not read \
-                                                     response code")),
-        }
-    }
-}
-
-/// Contains an SMTP reply, with separed code and message
-///
-/// The text message is optional, only the code is mandatory
-#[derive(PartialEq,Eq,Clone,Debug)]
-pub struct Response {
-    /// Response code
-    code: Code,
-    /// Server response string (optional)
-    /// Handle multiline responses
-    message: Vec<String>,
-}
-
-impl Response {
-    /// Creates a new `Response`
-    pub fn new(code: Code, message: Vec<String>) -> Response {
-        Response {
-            code: code,
-            message: message,
-        }
-    }
-
-    /// Tells if the response is positive
-    pub fn is_positive(&self) -> bool {
-        match self.code.severity {
-            PositiveCompletion => true,
-            PositiveIntermediate => true,
-            _ => false,
-        }
-    }
-
-    /// Returns the message
-    pub fn message(&self) -> Vec<String> {
-        self.message.clone()
-    }
-
-    /// Returns the severity (i.e. 1st digit)
-    pub fn severity(&self) -> Severity {
-        self.code.severity
-    }
-
-    /// Returns the category (i.e. 2nd digit)
-    pub fn category(&self) -> Category {
-        self.code.category
-    }
-
-    /// Returns the detail (i.e. 3rd digit)
-    pub fn detail(&self) -> u8 {
-        self.code.detail
-    }
-
-    /// Returns the reply code
-    fn code(&self) -> String {
-        self.code.code()
-    }
-
-    /// Tests code equality
-    pub fn has_code(&self, code: u16) -> bool {
-        self.code() == format!("{}", code)
-    }
-
-    /// Returns only the first word of the message if possible
-    pub fn first_word(&self) -> Option<String> {
-        match self.message.is_empty() {
-            true => None,
-            false => match self.message[0].split_whitespace().next() {
-                Some(word) => Some(word.to_string()),
-                None => None,
-            },
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::{Severity, Category, Response, ResponseParser, Code};
-
-    #[test]
-    fn test_severity_from_str() {
-        assert_eq!("2".parse::<Severity>().unwrap(),
-                   Severity::PositiveCompletion);
-        assert_eq!("4".parse::<Severity>().unwrap(),
-                   Severity::TransientNegativeCompletion);
-        assert!("1".parse::<Severity>().is_err());
-    }
-
-    #[test]
-    fn test_severity_fmt() {
-        assert_eq!(format!("{}", Severity::PositiveCompletion), "2");
-    }
-
-    #[test]
-    fn test_category_from_str() {
-        assert_eq!("2".parse::<Category>().unwrap(), Category::Connections);
-        assert_eq!("4".parse::<Category>().unwrap(), Category::Unspecified4);
-        assert!("6".parse::<Category>().is_err());
-    }
-
-    #[test]
-    fn test_category_fmt() {
-        assert_eq!(format!("{}", Category::Unspecified4), "4");
-    }
-
-    #[test]
-    fn test_code_new() {
-        assert_eq!(Code::new(Severity::TransientNegativeCompletion,
-                             Category::Connections,
-                             0),
-                   Code {
-                       severity: Severity::TransientNegativeCompletion,
-                       category: Category::Connections,
-                       detail: 0,
-                   });
-    }
-
-    #[test]
-    fn test_code_from_str() {
-        assert_eq!("421".parse::<Code>().unwrap(),
-                   Code {
-                       severity: Severity::TransientNegativeCompletion,
-                       category: Category::Connections,
-                       detail: 1,
-                   });
-    }
-
-    #[test]
-    fn test_code_code() {
-        let code = Code {
-            severity: Severity::TransientNegativeCompletion,
-            category: Category::Connections,
-            detail: 1,
-        };
-
-        assert_eq!(code.code(), "421");
-    }
-
-    #[test]
-    fn test_response_new() {
-        assert_eq!(Response::new(Code {
-                                     severity: "2".parse::<Severity>().unwrap(),
-                                     category: "4".parse::<Category>().unwrap(),
-                                     detail: 1,
-                                 },
-                                 vec!["me".to_string(),
-                                      "8BITMIME".to_string(),
-                                      "SIZE 42".to_string()]),
-                   Response {
-                       code: Code {
-                           severity: Severity::PositiveCompletion,
-                           category: Category::Unspecified4,
-                           detail: 1,
-                       },
-                       message: vec!["me".to_string(),
-                                     "8BITMIME".to_string(),
-                                     "SIZE 42".to_string()],
-                   });
-        assert_eq!(Response::new(Code {
-                                     severity: "2".parse::<Severity>().unwrap(),
-                                     category: "4".parse::<Category>().unwrap(),
-                                     detail: 1,
-                                 },
-                                 vec![]),
-                   Response {
-                       code: Code {
-                           severity: Severity::PositiveCompletion,
-                           category: Category::Unspecified4,
-                           detail: 1,
-                       },
-                       message: vec![],
-                   });
-    }
-
-    #[test]
-    fn test_response_parser() {
-        let mut parser = ResponseParser::new();
-
-        assert!(parser.read_line("250-me").unwrap());
-        assert!(parser.read_line("250-8BITMIME").unwrap());
-        assert!(parser.read_line("250-SIZE 42").unwrap());
-        assert!(!parser.read_line("250 AUTH PLAIN CRAM-MD5").unwrap());
-
-        let response = parser.response().unwrap();
-
-        assert_eq!(response,
-                   Response {
-                       code: Code {
-                           severity: Severity::PositiveCompletion,
-                           category: Category::MailSystem,
-                           detail: 0,
-                       },
-                       message: vec!["me".to_string(),
-                                     "8BITMIME".to_string(),
-                                     "SIZE 42".to_string(),
-                                     "AUTH PLAIN CRAM-MD5".to_string()],
-                   });
-    }
-
-    #[test]
-    fn test_response_is_positive() {
-        assert!(Response::new(Code {
-                                  severity: "2".parse::<Severity>().unwrap(),
-                                  category: "4".parse::<Category>().unwrap(),
-                                  detail: 1,
-                              },
-                              vec!["me".to_string(),
-                                   "8BITMIME".to_string(),
-                                   "SIZE 42".to_string()])
-                    .is_positive());
-        assert!(!Response::new(Code {
-                                   severity: "5".parse::<Severity>().unwrap(),
-                                   category: "4".parse::<Category>().unwrap(),
-                                   detail: 1,
-                               },
-                               vec!["me".to_string(),
-                                    "8BITMIME".to_string(),
-                                    "SIZE 42".to_string()])
-                     .is_positive());
-    }
-
-    #[test]
-    fn test_response_message() {
-        assert_eq!(Response::new(Code {
-                                     severity: "2".parse::<Severity>().unwrap(),
-                                     category: "4".parse::<Category>().unwrap(),
-                                     detail: 1,
-                                 },
-                                 vec!["me".to_string(),
-                                      "8BITMIME".to_string(),
-                                      "SIZE 42".to_string()])
-                       .message(),
-                   vec!["me".to_string(), "8BITMIME".to_string(), "SIZE 42".to_string()]);
-        let empty_message: Vec<String> = vec![];
-        assert_eq!(Response::new(Code {
-                                     severity: "2".parse::<Severity>().unwrap(),
-                                     category: "4".parse::<Category>().unwrap(),
-                                     detail: 1,
-                                 },
-                                 vec![])
-                       .message(),
-                   empty_message);
-    }
-
-    #[test]
-    fn test_response_severity() {
-        assert_eq!(Response::new(Code {
-                                     severity: "2".parse::<Severity>().unwrap(),
-                                     category: "4".parse::<Category>().unwrap(),
-                                     detail: 1,
-                                 },
-                                 vec!["me".to_string(),
-                                      "8BITMIME".to_string(),
-                                      "SIZE 42".to_string()])
-                       .severity(),
-                   Severity::PositiveCompletion);
-        assert_eq!(Response::new(Code {
-                                     severity: "5".parse::<Severity>().unwrap(),
-                                     category: "4".parse::<Category>().unwrap(),
-                                     detail: 1,
-                                 },
-                                 vec!["me".to_string(),
-                                      "8BITMIME".to_string(),
-                                      "SIZE 42".to_string()])
-                       .severity(),
-                   Severity::PermanentNegativeCompletion);
-    }
-
-    #[test]
-    fn test_response_category() {
-        assert_eq!(Response::new(Code {
-                                     severity: "2".parse::<Severity>().unwrap(),
-                                     category: "4".parse::<Category>().unwrap(),
-                                     detail: 1,
-                                 },
-                                 vec!["me".to_string(),
-                                      "8BITMIME".to_string(),
-                                      "SIZE 42".to_string()])
-                       .category(),
-                   Category::Unspecified4);
-    }
-
-    #[test]
-    fn test_response_detail() {
-        assert_eq!(Response::new(Code {
-                                     severity: "2".parse::<Severity>().unwrap(),
-                                     category: "4".parse::<Category>().unwrap(),
-                                     detail: 1,
-                                 },
-                                 vec!["me".to_string(),
-                                      "8BITMIME".to_string(),
-                                      "SIZE 42".to_string()])
-                       .detail(),
-                   1);
-    }
-
-    #[test]
-    fn test_response_code() {
-        assert_eq!(Response::new(Code {
-                                     severity: "2".parse::<Severity>().unwrap(),
-                                     category: "4".parse::<Category>().unwrap(),
-                                     detail: 1,
-                                 },
-                                 vec!["me".to_string(),
-                                      "8BITMIME".to_string(),
-                                      "SIZE 42".to_string()])
-                       .code(),
-                   "241");
-    }
-
-    #[test]
-    fn test_response_has_code() {
-        assert!(Response::new(Code {
-                                  severity: "2".parse::<Severity>().unwrap(),
-                                  category: "4".parse::<Category>().unwrap(),
-                                  detail: 1,
-                              },
-                              vec!["me".to_string(),
-                                   "8BITMIME".to_string(),
-                                   "SIZE 42".to_string()])
-                    .has_code(241));
-        assert!(!Response::new(Code {
-                                   severity: "2".parse::<Severity>().unwrap(),
-                                   category: "4".parse::<Category>().unwrap(),
-                                   detail: 1,
-                               },
-                               vec!["me".to_string(),
-                                    "8BITMIME".to_string(),
-                                    "SIZE 42".to_string()])
-                     .has_code(251));
-    }
-
-    #[test]
-    fn test_response_first_word() {
-        assert_eq!(Response::new(Code {
-                                     severity: "2".parse::<Severity>().unwrap(),
-                                     category: "4".parse::<Category>().unwrap(),
-                                     detail: 1,
-                                 },
-                                 vec!["me".to_string(),
-                                      "8BITMIME".to_string(),
-                                      "SIZE 42".to_string()])
-                       .first_word(),
-                   Some("me".to_string()));
-        assert_eq!(Response::new(Code {
-                                     severity: "2".parse::<Severity>().unwrap(),
-                                     category: "4".parse::<Category>().unwrap(),
-                                     detail: 1,
-                                 },
-                                 vec!["me mo".to_string(),
-                                      "8BITMIME".to_string(),
-                                      "SIZE 42".to_string()])
-                       .first_word(),
-                   Some("me".to_string()));
-        assert_eq!(Response::new(Code {
-                                     severity: "2".parse::<Severity>().unwrap(),
-                                     category: "4".parse::<Category>().unwrap(),
-                                     detail: 1,
-                                 },
-                                 vec![])
-                       .first_word(),
-                   None);
-        assert_eq!(Response::new(Code {
-                                     severity: "2".parse::<Severity>().unwrap(),
-                                     category: "4".parse::<Category>().unwrap(),
-                                     detail: 1,
-                                 },
-                                 vec![" ".to_string()])
-                       .first_word(),
-                   None);
-        assert_eq!(Response::new(Code {
-                                     severity: "2".parse::<Severity>().unwrap(),
-                                     category: "4".parse::<Category>().unwrap(),
-                                     detail: 1,
-                                 },
-                                 vec!["  ".to_string()])
-                       .first_word(),
-                   None);
-        assert_eq!(Response::new(Code {
-                                     severity: "2".parse::<Severity>().unwrap(),
-                                     category: "4".parse::<Category>().unwrap(),
-                                     detail: 1,
-                                 },
-                                 vec!["".to_string()])
-                       .first_word(),
-                   None);
-    }
-}

src/sender.rs

@@ -1,298 +0,0 @@
-//! Sends an email using the client
-
-use std::string::String;
-use std::net::{SocketAddr, ToSocketAddrs};
-
-use openssl::ssl::{SslMethod, SslContext};
-
-use SMTP_PORT;
-use extension::{Extension, ServerInfo};
-use error::{SmtpResult, Error};
-use email::SendableEmail;
-use client::Client;
-use authentication::Mecanism;
-
-/// Contains client configuration
-pub struct SenderBuilder {
-    /// Maximum connection reuse
-    ///
-    /// Zero means no limitation
-    connection_reuse_count_limit: u16,
-    /// Enable connection reuse
-    enable_connection_reuse: bool,
-    /// Name sent during HELO or EHLO
-    hello_name: String,
-    /// Credentials
-    credentials: Option<(String, String)>,
-    /// Socket we are connecting to
-    server_addr: SocketAddr,
-    /// SSL contexyt to use
-    ssl_context: Option<SslContext>,
-    /// List of authentication mecanism, sorted by priority
-    authentication_mecanisms: Vec<Mecanism>,
-}
-
-/// Builder for the SMTP Sender
-impl SenderBuilder {
-    /// Creates a new local SMTP client
-    pub fn new<A: ToSocketAddrs>(addr: A) -> Result<SenderBuilder, Error> {
-        let mut addresses = try!(addr.to_socket_addrs());
-
-        match addresses.next() {
-            Some(addr) => Ok(SenderBuilder {
-                server_addr: addr,
-                ssl_context: None,
-                credentials: None,
-                connection_reuse_count_limit: 100,
-                enable_connection_reuse: false,
-                hello_name: "localhost".to_string(),
-                authentication_mecanisms: vec![Mecanism::CramMd5, Mecanism::Plain],
-            }),
-            None => Err(From::from("Could nor resolve hostname")),
-        }
-    }
-
-    /// Creates a new local SMTP client to port 25
-    pub fn localhost() -> Result<SenderBuilder, Error> {
-        SenderBuilder::new(("localhost", SMTP_PORT))
-    }
-
-    /// Use STARTTLS with a specific context
-    pub fn ssl_context(mut self, ssl_context: SslContext) -> SenderBuilder {
-        self.ssl_context = Some(ssl_context);
-        self
-    }
-
-    /// Require SSL/TLS using STARTTLS
-    pub fn starttls(self) -> SenderBuilder {
-        self.ssl_context(SslContext::new(SslMethod::Tlsv1).unwrap())
-    }
-
-    /// Set the name used during HELO or EHLO
-    pub fn hello_name(mut self, name: &str) -> SenderBuilder {
-        self.hello_name = name.to_string();
-        self
-    }
-
-    /// Enable connection reuse
-    pub fn enable_connection_reuse(mut self, enable: bool) -> SenderBuilder {
-        self.enable_connection_reuse = enable;
-        self
-    }
-
-    /// Set the maximum number of emails sent using one connection
-    pub fn connection_reuse_count_limit(mut self, limit: u16) -> SenderBuilder {
-        self.connection_reuse_count_limit = limit;
-        self
-    }
-
-    /// Set the client credentials
-    pub fn credentials(mut self, username: &str, password: &str) -> SenderBuilder {
-        self.credentials = Some((username.to_string(), password.to_string()));
-        self
-    }
-
-    /// Set the authentication mecanisms
-    pub fn authentication_mecanisms(mut self, mecanisms: Vec<Mecanism>) -> SenderBuilder {
-        self.authentication_mecanisms = mecanisms;
-        self
-    }
-
-    /// Build the SMTP client
-    ///
-    /// It does not connects to the server, but only creates the `Sender`
-    pub fn build(self) -> Sender {
-        Sender::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
-pub struct Sender {
-    /// Information about the server
-    /// Value is None before HELO/EHLO
-    server_info: Option<ServerInfo>,
-    /// Sender variable states
-    state: State,
-    /// Information about the client
-    client_info: SenderBuilder,
-    /// 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.reset();
-                }
-                return Err(err)
-            },
-        }
-    })
-);
-
-impl Sender {
-    /// Creates a new SMTP client
-    ///
-    /// It does not connects to the server, but only creates the `Sender`
-    pub fn new(builder: SenderBuilder) -> Sender {
-
-        let client = Client::new();
-
-        Sender {
-            client: client,
-            server_info: None,
-            client_info: builder,
-            state: State {
-                panic: false,
-                connection_reuse_count: 0,
-            },
-        }
-    }
-
-    /// Reset the client state
-    fn reset(&mut self) {
-        // Close the SMTP transaction if needed
-        self.close();
-
-        // Reset the client state
-        self.server_info = None;
-        self.state.panic = false;
-        self.state.connection_reuse_count = 0;
-    }
-
-    /// Closes the inner connection
-    pub fn close(&mut self) {
-        self.client.close();
-    }
-
-    /// Gets the EHLO response and updates server information
-    pub fn get_ehlo(&mut self) -> SmtpResult {
-        // Extended Hello
-        let ehlo_response = try_smtp!(self.client.ehlo(&self.client_info.hello_name), 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)
-    }
-
-    /// Sends an email
-    pub fn send<T: SendableEmail>(&mut self, email: T) -> SmtpResult {
-        // Check if the connection is still available
-        if self.state.connection_reuse_count > 0 {
-            if !self.client.is_connected() {
-                self.reset();
-            }
-        }
-
-        // If there is a usable connection, test if the server answers and hello has been sent
-        if self.state.connection_reuse_count == 0 {
-            try!(self.client.connect(&self.client_info.server_addr));
-
-            // Log the connection
-            info!("connection established to {}", self.client_info.server_addr);
-
-            try!(self.get_ehlo());
-
-            if self.client_info.ssl_context.is_some() {
-                try_smtp!(self.client.starttls(), self);
-
-                try!(self.client
-                         .upgrade_tls_stream(self.client_info.ssl_context.as_ref().unwrap()));
-
-                try!(self.get_ehlo());
-            }
-
-            if self.client_info.credentials.is_some() && self.state.connection_reuse_count == 0 {
-                let (username, password) = self.client_info.credentials.clone().unwrap();
-
-                let mut found = false;
-
-                for mecanism in self.client_info.authentication_mecanisms.clone() {
-                    if self.server_info.as_ref().unwrap().supports_auth_mecanism(mecanism) {
-                        found = true;
-                        let result = self.client.auth(mecanism, &username, &password);
-                        try_smtp!(result, self);
-                    }
-                }
-
-                if !found {
-                    debug!("No supported authentication mecanisms available");
-                }
-            }
-        }
-
-        let current_message = try!(email.message_id().ok_or("Missing Message-ID"));
-        let from_address = try!(email.from_address().ok_or("Missing From address"));
-        let to_addresses = try!(email.to_addresses().ok_or("Missing To address"));
-        let message = try!(email.message().ok_or("Missing message"));
-
-        // Mail
-        let mail_options = match self.server_info
-                                     .as_ref()
-                                     .unwrap()
-                                     .supports_feature(&Extension::EightBitMime) {
-            true => Some("BODY=8BITMIME"),
-            false => None,
-        };
-
-        try_smtp!(self.client.mail(&from_address, mail_options), self);
-
-        // Log the mail command
-        info!("{}: from=<{}>", current_message, from_address);
-
-        // Recipient
-        for to_address in to_addresses.iter() {
-            try_smtp!(self.client.rcpt(&to_address), self);
-            // Log the rcpt command
-            info!("{}: to=<{}>", current_message, to_address);
-        }
-
-        // Data
-        try_smtp!(self.client.data(), self);
-
-        // Message content
-        let result = self.client.message(&message);
-
-        if result.is_ok() {
-            // Increment the connection reuse counter
-            self.state.connection_reuse_count = self.state.connection_reuse_count + 1;
-
-            // Log the message
-            info!("{}: conn_use={}, size={}, status=sent ({})",
-                  current_message,
-                  self.state.connection_reuse_count,
-                  message.len(),
-                  result.as_ref()
-                        .ok()
-                        .unwrap()
-                        .message()
-                        .iter()
-                        .next()
-                        .unwrap_or(&"no response".to_string()));
-        }
-
-        // Test if we can reuse the existing connection
-        if (!self.client_info.enable_connection_reuse) ||
-           (self.state.connection_reuse_count >= self.client_info.connection_reuse_count_limit) {
-            self.reset();
-        }
-
-        result
-    }
-}

tests/lib.rs

@@ -1,14 +0,0 @@
-// Copyright 2014 Alexis Mousset. See the COPYRIGHT
-// file at the top-level directory of this distribution.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[test]
-
-fn foo() {
-    assert!(true);
-}

website/.gitignore

@@ -0,0 +1,2 @@
+node_modules
+/_book

website/Makefile

@@ -0,0 +1,13 @@
+all: depends _book
+
+depends:
+	gitbook install
+
+serve:
+	gitbook serve
+
+_book:
+	gitbook build
+
+clean:
+	rm -rf _book/

website/book.json

@@ -0,0 +1,10 @@
+{
+    "root": "./content",
+    "plugins": [ "-sharing", "edit-link" ],
+    "pluginsConfig": {
+        "edit-link": {
+            "base": "https://github.com/lettre/lettre/edit/master/website/src",
+            "label": "Edit"
+        }
+    }
+}

website/content/README.md

@@ -0,0 +1,19 @@
+# Introduction
+
+Lettre is an email library that allows creating and sending messages. It provides:
+
+* An easy to use email builder
+* Pluggable email transports
+* Unicode support (for emails and transports, including for sender et recipient addresses when compatible)
+* Secure defaults (emails are only sent encrypted by default)
+
+The `lettre_email` crate allows you to compose messages, and the `lettre`
+provide transports to send them.
+
+Lettre requires Rust 1.20 or newer. Add the following to your `Cargo.toml`:
+
+```toml
+[dependencies]
+lettre = "0.8"
+lettre_email = "0.8"
+```

website/content/SUMMARY.md

@@ -0,0 +1,9 @@
+# Summary
+
+* [Introduction](README.md)
+* [Creating Messages](creating-messages/email.md)
+* [Sending Messages](sending-messages/_index.md)
+    * [SMTP Transport](sending-messages/smtp.md)
+    * [Sendmail Transport](sending-messages/sendmail.md)
+    * [File Transport](sending-messages/file.md)
+    * [Stub Transport](sending-messages/stub.md)

website/content/creating-messages/email.md

@@ -0,0 +1,65 @@
+### Creating messages
+
+This section explains how to create emails.
+
+#### Simple example
+
+The `email` part builds email messages. For now, it does not support attachments.
+An email is built using an `EmailBuilder`. The simplest email could be:
+
+```rust
+extern crate lettre_email;
+
+use lettre_email::EmailBuilder;
+
+fn main() {
+    // Create an email
+    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.")
+        .build();
+    
+    assert!(email.is_ok());
+}
+```
+
+When the `build` method is called, the `EmailBuilder` will add the missing headers (like
+`Message-ID` or `Date`) and check for missing necessary ones (like `From` or `To`). It will
+then generate an `Email` that can be sent.
+
+The `text()` method will create a plain text email, while the `html()` method will create an
+HTML email. You can use the `alternative()` method to provide both versions, using plain text
+as fallback for the HTML version.
+
+#### Complete example
+
+Below is a more complete example, not using method chaining:
+
+```rust
+extern crate lettre_email;
+
+use lettre_email::EmailBuilder;
+
+fn main() {
+    let mut builder = EmailBuilder::new();
+    builder.add_to(("user@example.org", "Alias name"));
+    builder.add_cc(("user@example.net", "Alias name"));
+    builder.add_from("no-reply@example.com");
+    builder.add_from("no-reply@example.eu");
+    builder.set_sender("no-reply@example.com");
+    builder.set_subject("Hello world");
+    builder.set_alternative("<h2>Hi, Hello world.</h2>", "Hi, Hello world.");
+    builder.add_reply_to("contact@example.com");
+    builder.add_header(("X-Custom-Header", "my header"));
+    
+    let email = builder.build();
+    assert!(email.is_ok());
+}
+```
+
+See the `EmailBuilder` documentation for a complete list of methods.
+

website/content/sending-messages/_index.md

@@ -0,0 +1,17 @@
+### Sending Messages
+
+This section explains how to manipulate emails you have created.
+
+This mailer contains several different transports for your emails. To be sendable, the
+emails have to implement `SendableEmail`, which is the case for emails created with `lettre_email`.
+
+The following transports are available:
+
+* The `SmtpTransport` uses the SMTP protocol to send the message over the network. It is
+  the preferred way of sending emails.
+* The `SendmailTransport` uses the sendmail command to send messages. It is an alternative to
+  the SMTP transport.
+* The `FileTransport` creates a file containing the email content to be sent. It can be used
+  for debugging or if you want to keep all sent emails.
+* The `StubTransport` is useful for debugging, and only prints the content of the email in the
+  logs.

website/content/sending-messages/file.md

@@ -0,0 +1,41 @@
+#### File Transport
+
+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.
+
+```rust
+extern crate lettre;
+
+use std::env::temp_dir;
+
+use lettre::file::FileEmailTransport;
+use lettre::{SimpleSendableEmail, EmailTransport};
+
+fn main() {
+    // Write to the local temp directory
+    let mut sender = FileEmailTransport::new(temp_dir());
+    let email = SimpleSendableEmail::new(
+                    "user@localhost".to_string(),
+                    &["root@localhost".to_string()],
+                    "message_id".to_string(),
+                    "Hello world".to_string(),
+                ).unwrap();
+    
+    let result = sender.send(&email);
+    assert!(result.is_ok());
+}
+```
+
+Example result in `/tmp/b7c211bc-9811-45ce-8cd9-68eab575d695.txt`:
+
+```text
+b7c211bc-9811-45ce-8cd9-68eab575d695: from=<user@localhost> to=<root@localhost>
+To: <root@localhost>
+From: <user@localhost>
+Subject: Hello
+Date: Sat, 31 Oct 2015 13:42:19 +0100
+Message-ID: <b7c211bc-9811-45ce-8cd9-68eab575d695.lettre@localhost>
+
+Hello World!
+```

website/content/sending-messages/sendmail.md

@@ -0,0 +1,23 @@
+#### Sendmail Transport
+
+The sendmail transport sends the email using the local sendmail command.
+
+```rust,no_run
+extern crate lettre;
+
+use lettre::sendmail::SendmailTransport;
+use lettre::{SimpleSendableEmail, EmailTransport};
+
+fn main() {
+    let email = SimpleSendableEmail::new(
+                    "user@localhost".to_string(),
+                    &["root@localhost".to_string()],
+                    "message_id".to_string(),
+                    "Hello world".to_string(),
+                ).unwrap();
+    
+    let mut sender = SendmailTransport::new();
+    let result = sender.send(&email);
+    assert!(result.is_ok());
+}
+```

website/content/sending-messages/smtp.md

@@ -0,0 +1,166 @@
+SMTP Transport
+
+This transport uses the SMTP protocol to send emails over the network (locally or remotely).
+
+It is designed to be:
+
+* Secured: email are encrypted by default
+* Modern: Unicode support for email content and sender/recipient addresses when compatible
+* Fast: supports tcp connection reuse
+
+This client is designed to send emails to a relay server, and should *not* be used to send
+emails directly to the destination.
+
+The relay server can be the local email server, a specific host or a third-party service.
+
+#### Simple example
+
+This is the most basic example of usage:
+
+```rust,no_run
+extern crate lettre;
+
+use lettre::{SimpleSendableEmail, EmailTransport, SmtpTransport};
+
+fn main() {
+    let email = SimpleSendableEmail::new(
+                    "user@localhost".to_string(),
+                    &["root@localhost".to_string()],
+                    "message_id".to_string(),
+                    "Hello world".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);
+    
+    assert!(result.is_ok());
+}
+```
+
+#### Complete example
+
+```rust,no_run
+extern crate lettre;
+
+use lettre::smtp::authentication::{Credentials, Mechanism};
+use lettre::{SimpleSendableEmail, EmailTransport, SmtpTransport};
+use lettre::smtp::extension::ClientId;
+use lettre::smtp::ConnectionReuseParameters;
+
+fn main() {
+    let email = SimpleSendableEmail::new(
+                    "user@localhost".to_string(),
+                    &["root@localhost".to_string()],
+                    "message_id".to_string(),
+                    "Hello world".to_string(),
+                ).unwrap();
+    
+    // Connect to a remote server on a custom port
+    let mut mailer = SmtpTransport::simple_builder("server.tld").unwrap()
+        // Set the name sent during EHLO/HELO, default is `localhost`
+        .hello_name(ClientId::Domain("my.hostname.tld".to_string()))
+        // Add credentials for authentication
+        .credentials(Credentials::new("username".to_string(), "password".to_string()))
+        // Enable SMTPUTF8 if the server supports it
+        .smtp_utf8(true)
+        // Configure expected authentication mechanism
+        .authentication_mechanism(Mechanism::Plain)
+        // Enable connection reuse
+        .connection_reuse(ConnectionReuseParameters::ReuseUnlimited).build();
+    
+    let result_1 = mailer.send(&email);
+    assert!(result_1.is_ok());
+    
+    // The second email will use the same connection
+    let result_2 = mailer.send(&email);
+    assert!(result_2.is_ok());
+    
+    // Explicitly close the SMTP transaction as we enabled connection reuse
+    mailer.close();
+}
+```
+
+You can specify custom TLS settings:
+
+```rust,no_run
+extern crate native_tls;
+extern crate lettre;
+extern crate lettre_email;
+
+use native_tls::TlsConnector;
+use native_tls::{Protocol};
+use lettre::smtp::authentication::{Credentials, Mechanism};
+use lettre::{EmailTransport, SimpleSendableEmail, ClientTlsParameters, ClientSecurity};
+use lettre::smtp::ConnectionReuseParameters;
+use lettre::smtp::{SmtpTransportBuilder};
+use lettre_email::EmailBuilder;
+
+fn main() {
+    let email = SimpleSendableEmail::new(
+                    "user@localhost".to_string(),
+                    &["root@localhost".to_string()],
+                    "message_id".to_string(),
+                    "Hello world".to_string(),
+                ).unwrap();
+
+    let mut tls_builder = TlsConnector::builder().unwrap();
+    tls_builder.supported_protocols(&[Protocol::Tlsv10]).unwrap();
+    let tls_parameters =
+        ClientTlsParameters::new(
+            "smtp.example.com".to_string(),
+            tls_builder.build().unwrap()
+        );
+
+    let mut mailer = SmtpTransportBuilder::new(
+        ("smtp.example.com", 465), ClientSecurity::Wrapper(tls_parameters)
+    )
+        .expect("Failed to create transport")
+        .authentication_mechanism(Mechanism::Login)
+        .credentials(Credentials::new(
+            "example_username".to_string(), "example_password".to_string()
+        ))
+        .connection_reuse(ConnectionReuseParameters::ReuseUnlimited)
+        .build();
+
+    let result = mailer.send(&email);
+    
+    assert!(result.is_ok());
+    
+    mailer.close();
+}
+```
+
+#### Lower level
+
+You can also send commands, here is a simple email transaction without
+error handling:
+
+```rust,no_run
+extern crate lettre;
+
+use lettre::EmailAddress;
+use lettre::smtp::SMTP_PORT;
+use lettre::smtp::client::Client;
+use lettre::smtp::client::net::NetworkStream;
+use lettre::smtp::extension::ClientId;
+use lettre::smtp::commands::*;
+
+fn main() {
+    let mut email_client: Client<NetworkStream> = Client::new();
+    let _ = email_client.connect(&("localhost", SMTP_PORT), None);
+    let _ = email_client.command(EhloCommand::new(ClientId::new("my_hostname".to_string())));
+    let _ = email_client.command(
+                MailCommand::new(Some(EmailAddress::new("user@example.com".to_string()).unwrap()), vec![])
+            );
+    let _ = email_client.command(
+                RcptCommand::new(EmailAddress::new("user@example.org".to_string()).unwrap(), vec![])
+            );
+    let _ = email_client.command(DataCommand);
+    let _ = email_client.message(Box::new("Test email".as_bytes()));
+    let _ = email_client.command(QuitCommand);
+}
+```
+

website/content/sending-messages/stub.md

@@ -0,0 +1,30 @@
+#### Stub Transport
+
+The stub transport only logs message envelope and drops the content. It can be useful for
+testing purposes.
+
+```rust
+extern crate lettre;
+
+use lettre::stub::StubEmailTransport;
+use lettre::{SimpleSendableEmail, EmailTransport};
+
+fn main() {
+    let email = SimpleSendableEmail::new(
+                    "user@localhost".to_string(),
+                    &["root@localhost".to_string()],
+                    "message_id".to_string(),
+                    "Hello world".to_string(),
+                ).unwrap();
+    
+    let mut sender = StubEmailTransport::new_positive();
+    let result = sender.send(&email);
+    assert!(result.is_ok());
+}
+```
+
+Will log (when using a logger like `env_logger`):
+
+```text
+b7c211bc-9811-45ce-8cd9-68eab575d695: from=<user@localhost> to=<root@localhost>
+```