diff --git a/go/src/gopkg.in/alexcesaro/quotedprintable.v2/LICENSE b/go/src/gopkg.in/alexcesaro/quotedprintable.v2/LICENSE
new file mode 100644
index 0000000..5f5c12a
--- /dev/null
+++ b/go/src/gopkg.in/alexcesaro/quotedprintable.v2/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Alexandre Cesaro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/go/src/gopkg.in/alexcesaro/quotedprintable.v2/README.google b/go/src/gopkg.in/alexcesaro/quotedprintable.v2/README.google
new file mode 100644
index 0000000..9ace3f7
--- /dev/null
+++ b/go/src/gopkg.in/alexcesaro/quotedprintable.v2/README.google
@@ -0,0 +1,10 @@
+URL: https://github.com/alexcesaro/quotedprintable/archive/9b4a113f96b3263b5223fe9c5fd1d1115811b343.zip
+Version: 44d228784e161379153583e31bcc32d9a25796e3
+License: The MIT License (MIT)
+License File: LICENSE
+
+Description:
+A Go package concerning quoted-printable encoding.
+
+Local Modifications:
+No modifications.
diff --git a/go/src/gopkg.in/alexcesaro/quotedprintable.v2/README.md b/go/src/gopkg.in/alexcesaro/quotedprintable.v2/README.md
new file mode 100644
index 0000000..afc82b0
--- /dev/null
+++ b/go/src/gopkg.in/alexcesaro/quotedprintable.v2/README.md
@@ -0,0 +1,20 @@
+# quotedprintable
+
+## Introduction
+
+Package quotedprintable implements quoted-printable and message header encoding
+as specified by RFC 2045 and RFC 2047.
+
+It is similar to the package currently being developed in the standard library: https://codereview.appspot.com/132680044/
+
+It requires Go 1.3 or newer.
+
+Some links:
+ - [Post on golang-dev](https://groups.google.com/d/topic/golang-dev/PK_ICQNJTmg/discussion)
+ - [issue on the bug traker](https://code.google.com/p/go/issues/detail?id=4943)
+ - [the former code review](https://codereview.appspot.com/101330049/)
+
+
+## Documentation
+
+https://godoc.org/gopkg.in/alexcesaro/quotedprintable.v2
diff --git a/go/src/gopkg.in/alexcesaro/quotedprintable.v2/header.go b/go/src/gopkg.in/alexcesaro/quotedprintable.v2/header.go
new file mode 100644
index 0000000..cd16f2c
--- /dev/null
+++ b/go/src/gopkg.in/alexcesaro/quotedprintable.v2/header.go
@@ -0,0 +1,407 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file defines encoding and decoding functions for encoded-words
+// as defined in RFC 2047.
+
+package quotedprintable
+
+import (
+	"bytes"
+	"encoding/base64"
+	"fmt"
+	"io"
+	"strings"
+	"sync"
+	"unicode/utf8"
+
+	"gopkg.in/alexcesaro/quotedprintable.v2/internal"
+)
+
+// Encoding represents the encoding used in encoded-words. It must be one of the
+// two encodings defined in RFC 2047 ("B" or "Q" encoding).
+type Encoding string
+
+const (
+	// Q represents the Q-encoding defined in RFC 2047.
+	Q Encoding = "Q"
+	// B represents the Base64 encoding defined in RFC 2045.
+	B Encoding = "B"
+)
+
+// A HeaderEncoder is an RFC 2047 encoded-word encoder.
+type HeaderEncoder struct {
+	charset    string
+	encoding   Encoding
+	splitWords bool
+}
+
+const maxEncodedWordLen = 75 // As defined in RFC 2047, section 2
+
+// NewHeaderEncoder returns a new HeaderEncoder to encode strings in the
+// specified charset.
+func (enc Encoding) NewHeaderEncoder(charset string) *HeaderEncoder {
+	// We automatically split encoded-words only when the charset is UTF-8
+	// because since multi-octet character must not be split across adjacent
+	// encoded-words (see RFC 2047, section 5) there is no way to split words
+	// without knowing how the charset works.
+	splitWords := strings.ToUpper(charset) == "UTF-8"
+
+	return &HeaderEncoder{charset, enc, splitWords}
+}
+
+// Encode encodes a string to be used as a MIME header value.
+func (e *HeaderEncoder) Encode(s string) string {
+	return e.encodeWord(s)
+}
+
+// NeedsEncoding returns whether the given header content needs to be encoded
+// into an encoded-words.
+func NeedsEncoding(s string) bool {
+	for i := 0; i < len(s); i++ {
+		b := s[i]
+		if (b > '~' || b < ' ') && b != '\t' {
+			return true
+		}
+	}
+
+	return false
+}
+
+type bufPool struct {
+	sync.Pool
+}
+
+func (b *bufPool) GetBuffer() *bytes.Buffer {
+	return bufFree.Get().(*bytes.Buffer)
+}
+
+func (b *bufPool) PutBuffer(buf *bytes.Buffer) {
+	if buf.Len() > 1024 {
+		return
+	}
+	buf.Reset()
+	b.Put(buf)
+}
+
+var bufFree = &bufPool{
+	sync.Pool{
+		New: func() interface{} {
+			return new(bytes.Buffer)
+		},
+	},
+}
+
+// encodeWord encodes a string into an encoded-word.
+func (e *HeaderEncoder) encodeWord(s string) string {
+	buf := bufFree.GetBuffer()
+	defer bufFree.PutBuffer(buf)
+
+	e.openWord(buf)
+
+	switch {
+	case e.encoding == B:
+		e.encodeWordB(buf, s)
+	default:
+		e.encodeWordQ(buf, s)
+	}
+
+	e.closeWord(buf)
+	return buf.String()
+}
+
+func (e *HeaderEncoder) encodeWordB(buf *bytes.Buffer, s string) {
+	maxLen := maxEncodedWordLen - buf.Len() - 2
+	if !e.splitWords || base64.StdEncoding.EncodedLen(len(s)) <= maxLen {
+		buf.WriteString(base64.StdEncoding.EncodeToString([]byte(s)))
+		return
+	}
+
+	v := []byte(s)
+	var n, last, runeSize int
+	for i := 0; i < len(s); i += runeSize {
+		runeSize = getRuneSize(s, i)
+
+		if base64.StdEncoding.EncodedLen(n+runeSize) <= maxLen {
+			n += runeSize
+		} else {
+			buf.WriteString(base64.StdEncoding.EncodeToString(v[last:i]))
+			e.splitWord(buf)
+			last = i
+			n = runeSize
+		}
+	}
+	buf.WriteString(base64.StdEncoding.EncodeToString(v[last:]))
+}
+
+func (e *HeaderEncoder) encodeWordQ(buf *bytes.Buffer, s string) {
+	if !e.splitWords {
+		for i := 0; i < len(s); i++ {
+			writeQ(buf, s[i])
+		}
+		return
+	}
+
+	var runeSize int
+	n := buf.Len()
+	for i := 0; i < len(s); i += runeSize {
+		b := s[i]
+		var encLen int
+		if b >= ' ' && b <= '~' && b != '=' && b != '?' && b != '_' {
+			encLen, runeSize = 1, 1
+		} else {
+			runeSize = getRuneSize(s, i)
+			encLen = 3 * runeSize
+		}
+
+		// We remove 2 to let spaces for closing chars "?="
+		if n+encLen > maxEncodedWordLen-2 {
+			n = e.splitWord(buf)
+		}
+		writeQString(buf, s[i:i+runeSize])
+		n += encLen
+	}
+}
+
+func (e *HeaderEncoder) openWord(buf *bytes.Buffer) int {
+	n := buf.Len()
+	buf.WriteString("=?")
+	buf.WriteString(e.charset)
+	buf.WriteByte('?')
+	buf.WriteString(string(e.encoding))
+	buf.WriteByte('?')
+
+	return buf.Len() - n
+}
+
+func (e *HeaderEncoder) closeWord(buf *bytes.Buffer) {
+	buf.WriteString("?=")
+}
+
+func (e *HeaderEncoder) splitWord(buf *bytes.Buffer) int {
+	e.closeWord(buf)
+	buf.WriteString("\r\n ")
+	return e.openWord(buf)
+}
+
+func getRuneSize(s string, i int) int {
+	runeSize := 1
+	for i+runeSize < len(s) && !utf8.RuneStart(s[i+runeSize]) {
+		runeSize++
+	}
+
+	return runeSize
+}
+
+func writeQString(buf *bytes.Buffer, s string) {
+	for i := 0; i < len(s); i++ {
+		writeQ(buf, s[i])
+	}
+}
+
+func writeQ(buf *bytes.Buffer, b byte) {
+	switch {
+	case b == ' ':
+		buf.WriteByte('_')
+	case b >= '!' && b <= '~' && b != '=' && b != '?' && b != '_':
+		buf.WriteByte(b)
+	default:
+		enc := make([]byte, 3)
+		internal.EncodeByte(enc, b)
+		buf.Write(enc)
+	}
+}
+
+// DecodeHeader decodes a MIME header by decoding all encoded-words of the
+// header. The returned text is encoded in the returned charset. Text is not
+// necessarily encoded in UTF-8. Returned charset is always upper case. This
+// function does not support decoding headers with multiple encoded-words
+// using different charsets.
+func DecodeHeader(header string) (text, charset string, err error) {
+	buf := bufFree.GetBuffer()
+	defer bufFree.PutBuffer(buf)
+
+	for {
+		i := strings.IndexByte(header, '=')
+		if i == -1 {
+			break
+		}
+		if i > 0 {
+			buf.WriteString(header[:i])
+			header = header[i:]
+		}
+
+		word := getEncodedWord(header)
+		if word == "" {
+			buf.WriteByte('=')
+			header = header[1:]
+			continue
+		}
+
+		for {
+			dec, wordCharset, err := decodeWord(word)
+			if err != nil {
+				buf.WriteString(word)
+				header = header[len(word):]
+				break
+			}
+			if charset == "" {
+				charset = wordCharset
+			} else if charset != wordCharset {
+				return "", "", fmt.Errorf("quotedprintable: multiple charsets in header are not supported: %q and %q used", charset, wordCharset)
+			}
+			buf.Write(dec)
+			header = header[len(word):]
+
+			// White-space and newline characters separating two encoded-words
+			// must be deleted.
+			var j int
+			for j = 0; j < len(header); j++ {
+				b := header[j]
+				if b != ' ' && b != '\t' && b != '\n' && b != '\r' {
+					break
+				}
+			}
+			if j == 0 {
+				// If there are no white-space characters following the current
+				// encoded-word there is nothing special to do.
+				break
+			}
+			word = getEncodedWord(header[j:])
+			if word == "" {
+				break
+			}
+			header = header[j:]
+		}
+	}
+	buf.WriteString(header)
+
+	return buf.String(), charset, nil
+}
+
+func getEncodedWord(s string) string {
+	if len(s) < 2 {
+		return ""
+	}
+	if s[0] != '=' {
+		return ""
+	}
+	if s[1] != '?' {
+		return ""
+	}
+
+	n := 2
+	for {
+		if n >= len(s) {
+			return ""
+		}
+
+		b := s[n]
+		if (b < '0' || b > '9') &&
+			(b < 'A' || b > 'Z') &&
+			(b < 'a' || b > 'z') &&
+			b != '-' {
+			break
+		}
+
+		n++
+	}
+	if s[n] != '?' {
+		return ""
+	}
+
+	if n+2 >= len(s) {
+		return ""
+	}
+	b := s[n+1]
+	if b != 'Q' && b != 'B' && b != 'q' && b != 'b' {
+		return ""
+	}
+	if s[n+2] != '?' {
+		return ""
+	}
+
+	n = n + 3
+	for {
+		if n >= len(s) {
+			return ""
+		}
+
+		if s[n] < ' ' || s[n] > '~' {
+			return ""
+		}
+		if s[n] == '?' {
+			n++
+			break
+		}
+		n++
+	}
+	if n >= len(s) || s[n] != '=' {
+		return ""
+	}
+
+	return s[0 : n+1]
+}
+
+func decodeWord(s string) (text []byte, charset string, err error) {
+	fields := strings.Split(s, "?")
+	if len(fields) != 5 || fields[0] != "=" || fields[4] != "=" || len(fields[2]) != 1 {
+		return []byte(s), "", nil
+	}
+
+	charset, enc, src := fields[1], fields[2], fields[3]
+
+	var dec []byte
+	switch Encoding(strings.ToUpper(enc)) {
+	case B:
+		if dec, err = base64.StdEncoding.DecodeString(src); err != nil {
+			return dec, charset, err
+		}
+	case Q:
+		if dec, err = qDecode(src); err != nil {
+			return dec, charset, err
+		}
+	default:
+		return []byte(""), charset, fmt.Errorf("quotedprintable: RFC 2047 encoding not supported: %q", enc)
+	}
+
+	return dec, strings.ToUpper(charset), nil
+}
+
+// qDecode decodes a Q encoded string.
+func qDecode(s string) ([]byte, error) {
+	length := len(s)
+	for i := 0; i < len(s); i++ {
+		if s[i] == '=' {
+			length -= 2
+			i += 2
+		}
+	}
+	dec := make([]byte, length)
+
+	n := 0
+	for i := 0; i < len(s); i++ {
+		switch c := s[i]; {
+		case c == '_':
+			dec[n] = ' '
+		case c == '=':
+			if i+2 >= len(s) {
+				return []byte(""), io.ErrUnexpectedEOF
+			}
+			buf, err := internal.ReadHexByte([]byte(s[i+1:]))
+			if err != nil {
+				return []byte(""), err
+			}
+			dec[n] = buf
+			i += 2
+		case (c >= ' ' && c <= '~') || c == '\n' || c == '\r' || c == '\t':
+			dec[n] = c
+		default:
+			return []byte(""), fmt.Errorf("quotedprintable: invalid unescaped byte %#02x in Q encoded string at byte %d", c, i)
+		}
+		n++
+	}
+
+	return dec, nil
+}
diff --git a/go/src/gopkg.in/alexcesaro/quotedprintable.v2/header_test.go b/go/src/gopkg.in/alexcesaro/quotedprintable.v2/header_test.go
new file mode 100644
index 0000000..8612ccb
--- /dev/null
+++ b/go/src/gopkg.in/alexcesaro/quotedprintable.v2/header_test.go
@@ -0,0 +1,115 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package quotedprintable
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func ExampleEncodeHeader() {
+	enc := Q.NewHeaderEncoder("UTF-8")
+	fmt.Println(enc.Encode("Coffee"))
+	fmt.Println(enc.Encode("Café"))
+	// Output:
+	// =?UTF-8?Q?Coffee?=
+	// =?UTF-8?Q?Caf=C3=A9?=
+}
+
+func ExampleNewHeaderEncoder() {
+	e := B.NewHeaderEncoder("UTF-8")
+	fmt.Printf(e.Encode("Caf\xc3"))
+	// Output: =?UTF-8?B?Q2Fmww==?=
+}
+
+func ExampleDecodeHeader() {
+	// text is not encoded in UTF-8 but in ISO-8859-1
+	text, charset, err := DecodeHeader("=?ISO-8859-1?Q?Caf=C3?=")
+	if err != nil {
+		panic(err)
+	}
+	fmt.Printf("Text: %q, charset: %q", text, charset)
+	// Output: Text: "Caf\xc3", charset: "ISO-8859-1"
+}
+
+func TestEncodeHeader(t *testing.T) {
+	utf8, iso88591 := "UTF-8", "iso-8859-1"
+	tests := []struct {
+		charset  string
+		encoding Encoding
+		src, exp string
+	}{
+		{utf8, Q, "François-Jérôme", "=?UTF-8?Q?Fran=C3=A7ois-J=C3=A9r=C3=B4me?="},
+		{utf8, B, "André", "=?UTF-8?B?QW5kcsOp?="},
+		{iso88591, Q, "Rapha\xebl Dupont", "=?iso-8859-1?Q?Rapha=EBl_Dupont?="},
+		{utf8, Q, "A", "=?UTF-8?Q?A?="},
+		{utf8, Q, "An 'encoded-word' may not be more than 75 characters long, including 'charset', 'encoding', 'encoded-text', and delimiters. ©", "=?UTF-8?Q?An_'encoded-word'_may_not_be_more_than_75_characters_long,_incl?=\r\n =?UTF-8?Q?uding_'charset',_'encoding',_'encoded-text',_and_delimiters._?=\r\n =?UTF-8?Q?=C2=A9?="},
+		{utf8, Q, strings.Repeat("0", 62) + "é", "=?UTF-8?Q?" + strings.Repeat("0", 62) + "?=\r\n =?UTF-8?Q?=C3=A9?="},
+		{utf8, B, strings.Repeat("é", 23), "=?UTF-8?B?w6nDqcOpw6nDqcOpw6nDqcOpw6nDqcOpw6nDqcOpw6nDqcOpw6nDqcOpw6k=?=\r\n =?UTF-8?B?w6k=?="},
+	}
+
+	for _, test := range tests {
+		e := test.encoding.NewHeaderEncoder(test.charset)
+		if s := e.Encode(test.src); s != test.exp {
+			t.Errorf("Encode(%q) = %q, want %q", test.src, s, test.exp)
+		}
+	}
+}
+
+func TestDecodeHeader(t *testing.T) {
+	tests := []struct {
+		src, exp, charset string
+		isError           bool
+	}{
+		{"=?UTF-8?Q?Fran=C3=A7ois-J=C3=A9r=C3=B4me?=", "François-Jérôme", "UTF-8", false},
+		{"=?UTF-8?q?ascii?=", "ascii", "UTF-8", false},
+		{"=?utf-8?B?QW5kcsOp?=", "André", "UTF-8", false},
+		{"=?ISO-8859-1?Q?Rapha=EBl_Dupont?=", "Rapha\xebl Dupont", "ISO-8859-1", false},
+		{"Jean", "Jean", "", false},
+		{"=?UTF-8?A?Test?=", "=?UTF-8?A?Test?=", "", false},
+		{"=?UTF-8?Q?A=B?=", "=?UTF-8?Q?A=B?=", "", false},
+		{"=?UTF-8?Q?=A?=", "=?UTF-8?Q?=A?=", "", false},
+		{"=?UTF-8?A?A?=", "=?UTF-8?A?A?=", "", false},
+		// Tests from RFC 2047
+		{"=?ISO-8859-1?Q?a?=", "a", "ISO-8859-1", false},
+		{"=?ISO-8859-1?Q?a?= b", "a b", "ISO-8859-1", false},
+		{"=?ISO-8859-1?Q?a?= =?ISO-8859-1?Q?b?=", "ab", "ISO-8859-1", false},
+		{"=?ISO-8859-1?Q?a?=  =?ISO-8859-1?Q?b?=", "ab", "ISO-8859-1", false},
+		{"=?ISO-8859-1?Q?a?= \r\n\t =?ISO-8859-1?Q?b?=", "ab", "ISO-8859-1", false},
+		{"=?ISO-8859-1?Q?a_b?=", "a b", "ISO-8859-1", false},
+		{"=?ISO-8859-1?Q?a?= =?ISO-8859-2?Q?_b?=", "", "", true},
+	}
+
+	for _, test := range tests {
+		s, charset, err := DecodeHeader(test.src)
+		if test.isError && err == nil {
+			t.Errorf("DecodeHeader(%q) should return an error", test.src)
+		}
+		if !test.isError && err != nil {
+			t.Errorf("DecodeHeader(%q): %v", test.src, err)
+		}
+		if s != test.exp || charset != test.charset {
+			t.Errorf("DecodeHeader(%q) = %q (charset=%q), want %q (charset=%q)", test.src, s, charset, test.exp, test.charset)
+		}
+	}
+}
+
+var testHeader = "¡Hola, señor!"
+
+func BenchmarkQEncode(b *testing.B) {
+	enc := Q.NewHeaderEncoder("UTF-8")
+	for i := 0; i < b.N; i++ {
+		enc.Encode(testHeader)
+	}
+}
+
+func BenchmarkBEncode(b *testing.B) {
+	encoder := &HeaderEncoder{charset: "UTF-8", encoding: B, splitWords: true}
+
+	for i := 0; i < b.N; i++ {
+		encoder.Encode(testHeader)
+	}
+}
diff --git a/go/src/gopkg.in/alexcesaro/quotedprintable.v2/internal/quotedprintable.go b/go/src/gopkg.in/alexcesaro/quotedprintable.v2/internal/quotedprintable.go
new file mode 100644
index 0000000..8b08bd0
--- /dev/null
+++ b/go/src/gopkg.in/alexcesaro/quotedprintable.v2/internal/quotedprintable.go
@@ -0,0 +1,43 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package internal contains quoted-printable internals shared by mime and
+// mime/quotedprintable.
+package internal
+
+import "fmt"
+
+// EncodeByte encodes a byte using the quoted-printable encoding.
+func EncodeByte(dst []byte, b byte) {
+	dst[0] = '='
+	dst[1] = upperhex[b>>4]
+	dst[2] = upperhex[b&0x0f]
+}
+
+const upperhex = "0123456789ABCDEF"
+
+func fromHex(b byte) (byte, error) {
+	switch {
+	case b >= '0' && b <= '9':
+		return b - '0', nil
+	case b >= 'A' && b <= 'F':
+		return b - 'A' + 10, nil
+	// Accept badly encoded bytes
+	case b >= 'a' && b <= 'f':
+		return b - 'a' + 10, nil
+	}
+	return 0, fmt.Errorf("quotedprintable: invalid quoted-printable hex byte %#02x", b)
+}
+
+// ReadHexByte returns the byte represented by an hexadecimal byte slice of length 2.
+func ReadHexByte(v []byte) (b byte, err error) {
+	var hb, lb byte
+	if hb, err = fromHex(v[0]); err != nil {
+		return 0, err
+	}
+	if lb, err = fromHex(v[1]); err != nil {
+		return 0, err
+	}
+	return hb<<4 | lb, nil
+}
diff --git a/go/src/gopkg.in/alexcesaro/quotedprintable.v2/quotedprintable.go b/go/src/gopkg.in/alexcesaro/quotedprintable.v2/quotedprintable.go
new file mode 100644
index 0000000..2a48283
--- /dev/null
+++ b/go/src/gopkg.in/alexcesaro/quotedprintable.v2/quotedprintable.go
@@ -0,0 +1,223 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file defines quoted-printable decoders and encoders, as specified in RFC
+// 2045.
+// Deviations:
+// 1. in addition to "=\r\n", "=\n" is also treated as soft line break.
+// 2. it will pass through a '\r' or '\n' not preceded by '=', consistent
+//    with other broken QP encoders and decoders.
+
+// Package quotedprintable implements quoted-printable and message header
+// encoding as specified by RFC 2045 and RFC 2047.
+package quotedprintable
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+
+	"gopkg.in/alexcesaro/quotedprintable.v2/internal"
+)
+
+// Encode encodes src into at most MaxEncodedLen(len(src)) bytes to dst,
+// returning the actual number of bytes written to dst.
+func Encode(dst, src []byte) int {
+	n := 0
+	for i, c := range src {
+		switch {
+		case c != '=' && (c >= '!' && c <= '~' || c == '\n' || c == '\r'):
+			dst[n] = c
+			n++
+		case c == ' ' || c == '\t':
+			if isLastChar(i, src) {
+				internal.EncodeByte(dst[n:], c)
+				n += 3
+			} else {
+				dst[n] = c
+				n++
+			}
+		default:
+			internal.EncodeByte(dst[n:], c)
+			n += 3
+		}
+	}
+
+	return n
+}
+
+// isLastChar returns true if byte i is the last character of the line.
+func isLastChar(i int, src []byte) bool {
+	return i == len(src)-1 ||
+		(i < len(src)-1 && src[i+1] == '\n') ||
+		(i < len(src)-2 && src[i+1] == '\r' && src[i+2] == '\n')
+}
+
+// EncodeToString returns the quoted-printable encoding of src.
+func EncodeToString(src []byte) string {
+	dbuf := make([]byte, MaxEncodedLen(len(src)))
+	n := Encode(dbuf, src)
+	return string(dbuf[:n])
+}
+
+// MaxEncodedLen returns the maximum length of an encoding of n source bytes.
+func MaxEncodedLen(n int) int { return 3 * n }
+
+// NewEncoder returns a new quoted-printable stream encoder. Data written to the
+// returned writer will be encoded and then written to w.
+func NewEncoder(w io.Writer) io.Writer {
+	return &encoder{w}
+}
+
+type encoder struct {
+	w io.Writer
+}
+
+func (e *encoder) Write(p []byte) (int, error) {
+	dbuf := make([]byte, MaxEncodedLen(len(p)))
+	n := Encode(dbuf, p)
+	n, err := e.w.Write(dbuf[:n])
+	if err != nil {
+		nn := 0
+		for i := 0; i < n; i++ {
+			if dbuf[i] == '=' {
+				if i+2 >= n {
+					break
+				}
+				i += 2
+			}
+			nn++
+		}
+		return nn, err
+	}
+
+	return len(p), nil
+}
+
+// Decode decodes src into at most MaxDecodedLen(len(src)) bytes to dst,
+// returning the actual number of bytes written to dst.
+func Decode(dst, src []byte) (n int, err error) {
+	var eol, trimLen, eolLen int
+	for i := 0; i < len(src); i++ {
+		if i == eol {
+			eol = bytes.IndexByte(src[i:], '\n') + i + 1
+			if eol == i {
+				eol = len(src)
+				eolLen = 0
+			} else if eol-2 >= i && src[eol-2] == '\r' {
+				eolLen = 2
+			} else {
+				eolLen = 1
+			}
+
+			// Count the number of bytes to trim
+			trimLen = 0
+			for {
+				if trimLen == eol-eolLen-i {
+					break
+				}
+
+				switch src[eol-eolLen-trimLen-1] {
+				case '\n', '\r', ' ', '\t':
+					trimLen++
+					continue
+				case '=':
+					if trimLen > 0 {
+						trimLen += eolLen + 1
+						eolLen = 0
+						err = fmt.Errorf("quotedprintable: invalid bytes after =: %q", src[eol-trimLen+1:eol])
+					} else {
+						trimLen = eolLen + 1
+						eolLen = 0
+					}
+				}
+				break
+			}
+		}
+
+		// Skip trimmable bytes
+		if trimLen > 0 && i == eol-trimLen-eolLen {
+			if err != nil {
+				return n, err
+			}
+
+			i += trimLen - 1
+			continue
+		}
+
+		switch c := src[i]; {
+		case c == '=':
+			if i+2 >= len(src) {
+				return n, io.ErrUnexpectedEOF
+			}
+			b, convErr := internal.ReadHexByte(src[i+1:])
+			if convErr != nil {
+				return n, convErr
+			}
+			dst[n] = b
+			n++
+			i += 2
+		case (c >= ' ' && c <= '~') || c == '\n' || c == '\r' || c == '\t':
+			dst[n] = c
+			n++
+		default:
+			return n, fmt.Errorf("quotedprintable: invalid unescaped byte 0x%02x in quoted-printable body", c)
+		}
+	}
+
+	return n, nil
+}
+
+// MaxDecodedLen returns the maximum length of a decoding of n source bytes.
+func MaxDecodedLen(n int) int { return n }
+
+// DecodeString returns the bytes represented by the quoted-printable string s.
+func DecodeString(s string) ([]byte, error) {
+	dbuf := make([]byte, MaxDecodedLen(len(s)))
+	n, err := Decode(dbuf, []byte(s))
+	return dbuf[:n], err
+}
+
+// NewDecoder returns a new quoted-printable stream decoder.
+func NewDecoder(r io.Reader) io.Reader {
+	return &qpReader{br: bufio.NewReader(r)}
+}
+
+type qpReader struct {
+	br   *bufio.Reader
+	line []byte
+	eof  bool
+	err  error
+}
+
+func (q *qpReader) Read(p []byte) (int, error) {
+	n := 0
+	for n < len(p) {
+		if len(q.line) == 0 {
+			if q.err != nil {
+				return n, q.err
+			} else if q.eof {
+				return n, io.EOF
+			}
+
+			q.line, q.err = q.br.ReadSlice('\n')
+			if q.err == io.EOF {
+				q.eof = true
+			} else if q.err != nil {
+				return n, q.err
+			}
+
+			var nn int
+			nn, q.err = Decode(q.line, q.line)
+			q.line = q.line[:nn]
+		}
+
+		nn := copy(p[n:], q.line)
+		n += nn
+		q.line = q.line[nn:]
+	}
+
+	return n, nil
+}
diff --git a/go/src/gopkg.in/alexcesaro/quotedprintable.v2/quotedprintable_test.go b/go/src/gopkg.in/alexcesaro/quotedprintable.v2/quotedprintable_test.go
new file mode 100644
index 0000000..bb5a710
--- /dev/null
+++ b/go/src/gopkg.in/alexcesaro/quotedprintable.v2/quotedprintable_test.go
@@ -0,0 +1,313 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package quotedprintable
+
+import (
+	"bufio"
+	"bytes"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"regexp"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+)
+
+func ExampleEncodeToString() {
+	data := []byte("¡Hola, señor!")
+	str := EncodeToString(data)
+	fmt.Println(str)
+	// Output:
+	// =C2=A1Hola, se=C3=B1or!
+}
+
+func ExampleDecodeString() {
+	str := "=C2=A1Hola, se=C3=B1or!"
+	data, err := DecodeString(str)
+	if err != nil {
+		fmt.Println("error:", err)
+		return
+	}
+	fmt.Printf("%s\n", data)
+	// Output:
+	// ¡Hola, señor!
+}
+
+func ExampleNewEncoder() {
+	input := []byte("Café")
+	encoder := NewEncoder(os.Stdout)
+	encoder.Write(input)
+	// Output:
+	// Caf=C3=A9
+}
+
+func TestQuotedPrintable(t *testing.T) {
+	tests := []struct {
+		in, want string
+		err      interface{}
+	}{
+		{in: "", want: ""},
+		{in: "foo bar", want: "foo bar"},
+		{in: "foo bar=3D", want: "foo bar="},
+		{in: "foo bar=3d", want: "foo bar="}, // lax.
+		{in: "foo bar=\n", want: "foo bar"},
+		{in: "foo bar\n", want: "foo bar\n"}, // somewhat lax.
+		{in: "foo bar=0", want: "foo bar", err: io.ErrUnexpectedEOF},
+		{in: "foo bar=0D=0A", want: "foo bar\r\n"},
+		{in: " A B        \r\n C ", want: " A B\r\n C"},
+		{in: " A B =\r\n C ", want: " A B  C"},
+		{in: " A B =\n C ", want: " A B  C"}, // lax. treating LF as CRLF
+		{in: "foo=\nbar", want: "foobar"},
+		{in: "foo\x00bar", want: "foo", err: "quotedprintable: invalid unescaped byte 0x00 in quoted-printable body"},
+		{in: "foo bar\xff", want: "foo bar", err: "quotedprintable: invalid unescaped byte 0xff in quoted-printable body"},
+
+		// Equal sign.
+		{in: "=3D30\n", want: "=30\n"},
+		{in: "=00=FF0=\n", want: "\x00\xff0"},
+
+		// Trailing whitespace
+		{in: "foo  \n", want: "foo\n"},
+		{in: "foo  \n\nfoo =\n\nfoo=20\n\n", want: "foo\n\nfoo \nfoo \n\n"},
+
+		// Tests that we allow bare \n and \r through, despite it being strictly
+		// not permitted per RFC 2045, Section 6.7 Page 22 bullet (4).
+		{in: "foo\nbar", want: "foo\nbar"},
+		{in: "foo\rbar", want: "foo\rbar"},
+		{in: "foo\r\nbar", want: "foo\r\nbar"},
+
+		// Different types of soft line-breaks.
+		{in: "foo=\r\nbar", want: "foobar"},
+		{in: "foo=\nbar", want: "foobar"},
+		{in: "foo=\rbar", want: "foo", err: "quotedprintable: invalid quoted-printable hex byte 0x0d"},
+		{in: "foo=\r\r\r \nbar", want: "foo", err: `quotedprintable: invalid bytes after =: "\r\r\r \n"`},
+
+		// Example from RFC 2045:
+		{in: "Now's the time =\n" + "for all folk to come=\n" + " to the aid of their country.",
+			want: "Now's the time for all folk to come to the aid of their country."},
+	}
+	for _, tt := range tests {
+		var buf bytes.Buffer
+		_, err := io.Copy(&buf, NewDecoder(strings.NewReader(tt.in)))
+		if got := buf.String(); got != tt.want {
+			t.Errorf("for %q, got %q; want %q", tt.in, got, tt.want)
+		}
+		switch verr := tt.err.(type) {
+		case nil:
+			if err != nil {
+				t.Errorf("for %q, got unexpected error: %v", tt.in, err)
+			}
+		case string:
+			if got := fmt.Sprint(err); got != verr {
+				t.Errorf("for %q, got error %q; want %q", tt.in, got, verr)
+			}
+		case error:
+			if err != verr {
+				t.Errorf("for %q, got error %q; want %q", tt.in, err, verr)
+			}
+		}
+	}
+
+}
+
+func everySequence(base, alpha string, length int, fn func(string)) {
+	if len(base) == length {
+		fn(base)
+		return
+	}
+	for i := 0; i < len(alpha); i++ {
+		everySequence(base+alpha[i:i+1], alpha, length, fn)
+	}
+}
+
+var useQprint = flag.Bool("qprint", false, "Compare against the 'qprint' program.")
+
+var badSoftRx = regexp.MustCompile(`=([^\r\n]+?\n)|([^\r\n]+$)|(\r$)|(\r[^\n]+\n)|( \r\n)`)
+
+func TestQPExhaustive(t *testing.T) {
+	if *useQprint {
+		_, err := exec.LookPath("qprint")
+		if err != nil {
+			t.Fatalf("Error looking for qprint: %v", err)
+		}
+	}
+
+	var buf bytes.Buffer
+	res := make(map[string]int)
+	everySequence("", "0A \r\n=", 6, func(s string) {
+		if strings.HasSuffix(s, "=") || strings.Contains(s, "==") {
+			return
+		}
+		buf.Reset()
+		_, err := io.Copy(&buf, NewDecoder(strings.NewReader(s)))
+		if err != nil {
+			errStr := err.Error()
+			if strings.Contains(errStr, "invalid bytes after =:") {
+				errStr = "invalid bytes after ="
+			}
+			res[errStr]++
+			if strings.Contains(errStr, "invalid quoted-printable hex byte ") {
+				if strings.HasSuffix(errStr, "0x20") && (strings.Contains(s, "=0 ") || strings.Contains(s, "=A ") || strings.Contains(s, "= ")) {
+					return
+				}
+				if strings.HasSuffix(errStr, "0x3d") && (strings.Contains(s, "=0=") || strings.Contains(s, "=A=")) {
+					return
+				}
+				if strings.HasSuffix(errStr, "0x0a") || strings.HasSuffix(errStr, "0x0d") {
+					// bunch of cases; since whitespace at the end of a line before \n is removed.
+					return
+				}
+			}
+			if strings.Contains(errStr, "unexpected EOF") {
+				return
+			}
+			if errStr == "invalid bytes after =" && badSoftRx.MatchString(s) {
+				return
+			}
+			t.Errorf("decode(%q) = %v", s, err)
+			return
+		}
+		if *useQprint {
+			cmd := exec.Command("qprint", "-d")
+			cmd.Stdin = strings.NewReader(s)
+			stderr, err := cmd.StderrPipe()
+			if err != nil {
+				panic(err)
+			}
+			qpres := make(chan interface{}, 2)
+			go func() {
+				br := bufio.NewReader(stderr)
+				s, _ := br.ReadString('\n')
+				if s != "" {
+					qpres <- errors.New(s)
+					if cmd.Process != nil {
+						// It can get stuck on invalid input, like:
+						// echo -n "0000= " | qprint -d
+						cmd.Process.Kill()
+					}
+				}
+			}()
+			go func() {
+				want, err := cmd.Output()
+				if err == nil {
+					qpres <- want
+				}
+			}()
+			select {
+			case got := <-qpres:
+				if want, ok := got.([]byte); ok {
+					if string(want) != buf.String() {
+						t.Errorf("go decode(%q) = %q; qprint = %q", s, want, buf.String())
+					}
+				} else {
+					t.Logf("qprint -d(%q) = %v", s, got)
+				}
+			case <-time.After(5 * time.Second):
+				t.Logf("qprint timeout on %q", s)
+			}
+		}
+		res["OK"]++
+	})
+	var outcomes []string
+	for k, v := range res {
+		outcomes = append(outcomes, fmt.Sprintf("%v: %d", k, v))
+	}
+	sort.Strings(outcomes)
+	got := strings.Join(outcomes, "\n")
+	want := `OK: 21576
+invalid bytes after =: 3397
+quotedprintable: invalid quoted-printable hex byte 0x0a: 1190
+quotedprintable: invalid quoted-printable hex byte 0x0d: 3325
+quotedprintable: invalid quoted-printable hex byte 0x20: 3325
+quotedprintable: invalid quoted-printable hex byte 0x3d: 810
+unexpected EOF: 1502`
+	if got != want {
+		t.Errorf("Got:\n%s\nWant:\n%s", got, want)
+	}
+}
+
+func TestEncodeToString(t *testing.T) {
+	tests := []struct {
+		in, want string
+	}{
+		{in: "", want: ""},
+		{in: "foo bar", want: "foo bar"},
+		{in: "foo bar=", want: "foo bar=3D"},
+		{in: "foo bar\n", want: "foo bar\n"},
+		{in: "foo bar\r\n", want: "foo bar\r\n"},
+		{in: "foo bar ", want: "foo bar=20"},
+		{in: "foo bar  ", want: "foo bar =20"},
+		{in: "foo bar \n", want: "foo bar=20\n"},
+		{in: "foo bar  \n", want: "foo bar =20\n"},
+		{in: "foo bar  \n ", want: "foo bar =20\n=20"},
+		{in: "résumé", want: "r=C3=A9sum=C3=A9"},
+		{in: "\t !\"#$%&'()*+,-./ :;<>?@[\\]^_`{|}~", want: "\t !\"#$%&'()*+,-./ :;<>?@[\\]^_`{|}~"},
+	}
+
+	for _, tt := range tests {
+		got := EncodeToString([]byte(tt.in))
+		if got != tt.want {
+			t.Errorf("EncodeToString(%q), got %q; want %q", tt.in, got, tt.want)
+		}
+	}
+}
+
+type brokenWriter struct {
+	errorByte int
+	*bytes.Buffer
+}
+
+func (w *brokenWriter) Write(p []byte) (int, error) {
+	for i, b := range p {
+		if i == w.errorByte {
+			return i, errors.New("Broken writer error")
+		}
+		w.WriteByte(b)
+	}
+
+	return len(p), nil
+}
+
+func newBrokenWriter(l int) *brokenWriter {
+	return &brokenWriter{l, new(bytes.Buffer)}
+}
+
+func TestEncoder(t *testing.T) {
+	tests := []struct {
+		in, want     string
+		errorByte, n int
+		isError      bool
+	}{
+		{in: "a", want: "", errorByte: 0, n: 0, isError: true},
+		{in: "a", want: "a", errorByte: 1, n: 1, isError: false},
+		{in: "=", want: "=", errorByte: 1, n: 0, isError: true},
+		{in: "=", want: "=3", errorByte: 2, n: 0, isError: true},
+		{in: "=", want: "=3D", errorByte: 3, n: 1, isError: false},
+		{in: "==", want: "=3D", errorByte: 3, n: 1, isError: true},
+		{in: "==", want: "=3D=", errorByte: 4, n: 1, isError: true},
+		{in: "==", want: "=3D=3", errorByte: 5, n: 1, isError: true},
+		{in: " \r\n", want: "=20\r", errorByte: 4, n: 2, isError: true},
+	}
+
+	for _, tt := range tests {
+		w := newBrokenWriter(tt.errorByte)
+		n, err := NewEncoder(w).Write([]byte(tt.in))
+		if tt.isError && (err == nil) {
+			t.Errorf("NewEncoder.Write(%q) with error at byte %d should return an error", tt.in, tt.errorByte)
+		} else if !tt.isError && (err != nil) {
+			t.Errorf("NewEncoder.Write(%q) with error at byte %d should not return an error", tt.in, tt.errorByte)
+		}
+		if w.String() != tt.want {
+			t.Errorf("NewEncoder.Write(%q) with error at byte %d, got %q; want %q", tt.in, tt.errorByte, w.String(), tt.want)
+		}
+		if n != tt.n {
+			t.Errorf("NewEncoder.Write(%q) with error at byte %d, got n=%d; want n=%d", tt.in, tt.errorByte, n, tt.n)
+		}
+	}
+}
diff --git a/go/src/gopkg.in/gomail.v1/LICENSE b/go/src/gopkg.in/gomail.v1/LICENSE
new file mode 100644
index 0000000..5f5c12a
--- /dev/null
+++ b/go/src/gopkg.in/gomail.v1/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Alexandre Cesaro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/go/src/gopkg.in/gomail.v1/README.google b/go/src/gopkg.in/gomail.v1/README.google
new file mode 100644
index 0000000..46fcc63
--- /dev/null
+++ b/go/src/gopkg.in/gomail.v1/README.google
@@ -0,0 +1,10 @@
+URL: https://github.com/go-gomail/gomail/archive/11b919ab4933936a28fb6aeda5c6523091266f37.zip
+Version: 11b919ab4933936a28fb6aeda5c6523091266f37
+License: The MIT License (MIT)
+License File: LICENSE
+
+Description:
+The best way to send emails in Go.
+
+Local Modifications:
+No modifications.
diff --git a/go/src/gopkg.in/gomail.v1/README.md b/go/src/gopkg.in/gomail.v1/README.md
new file mode 100644
index 0000000..70f7acf
--- /dev/null
+++ b/go/src/gopkg.in/gomail.v1/README.md
@@ -0,0 +1,97 @@
+# Gomail
+
+## Introduction
+
+Gomail is a very simple and powerful package to send emails.
+
+It requires Go 1.3 or newer.
+
+
+## Features
+
+ * Dead-simple API
+ * Highly flexible
+ * Backward compatibility promise
+ * Supports HTML and text templates
+ * Attachments
+ * Embedded images
+ * SSL/TLS support
+ * Automatic encoding of special characters
+ * Well-documented
+ * High test coverage
+
+
+## Documentation
+
+https://godoc.org/gopkg.in/gomail.v1
+
+
+## Download
+
+    go get gopkg.in/gomail.v1
+
+
+## Example
+
+```go
+package main
+
+import (
+	"gopkg.in/gomail.v1"
+)
+
+func main() {
+	msg := gomail.NewMessage()
+	msg.SetHeader("From", "alex@example.com")
+	msg.SetHeader("To", "bob@example.com", "cora@example.com")
+	msg.SetAddressHeader("Cc", "dan@example.com", "Dan")
+	msg.SetHeader("Subject", "Hello!")
+	msg.SetBody("text/html", "Hello <b>Bob</b> and <i>Cora</i>!")
+
+	f, err := gomail.OpenFile("/home/Alex/lolcat.jpg")
+	if err != nil {
+		panic(err)
+	}
+	msg.Attach(f)
+
+	// Send the email to Bob, Cora and Dan
+	mailer := gomail.NewMailer("smtp.example.com", "user", "123456", 587)
+	if err := mailer.Send(msg); err != nil {
+		panic(err)
+	}
+}
+```
+
+
+## FAQ
+
+### x509: certificate signed by unknown authority
+
+If you get this error it means the certificate used by the SMTP server is not
+considered valid by the client running Gomail. As a quick workaround you can
+bypass the verification of the server's certificate chain and host name by using
+`SetTLSConfig`:
+
+    mailer := gomail.NewMailer("smtp.example.com", "user", "123456", 587, gomail.SetTLSConfig(&tls.Config{InsecureSkipVerify: true}))
+
+Note, however, that this is insecure and should not be used in production.
+
+### 504 5.7.4 Unrecognized authentication type
+
+If you get this error, you should try using the LOGIN authentication mechanism:
+
+    addr := "smtp.example.com:587"
+    auth := gomail.LoginAuth("username", "password", "smtp.example.com")
+    mailer := gomail.NewCustomMailer(addr, auth)
+
+See [issue #16](https://github.com/go-gomail/gomail/issues/16).
+
+
+## Contact
+
+You are more than welcome to open issues and send pull requests if you find a
+bug or need a new feature.
+
+You can also ask questions on the [Gomail
+thread](https://groups.google.com/d/topic/golang-nuts/ywPpNlmSt6U/discussion)
+in the Go mailing-list or via Twitter [@alexandrecesaro](https://twitter.com/alexandrecesaro).
diff --git a/go/src/gopkg.in/gomail.v1/export.go b/go/src/gopkg.in/gomail.v1/export.go
new file mode 100644
index 0000000..1f56cd3
--- /dev/null
+++ b/go/src/gopkg.in/gomail.v1/export.go
@@ -0,0 +1,262 @@
+package gomail
+
+import (
+	"bytes"
+	"encoding/base64"
+	"io"
+	"mime/multipart"
+	"net/mail"
+	"time"
+
+	"gopkg.in/alexcesaro/quotedprintable.v2"
+)
+
+// Export converts the message into a net/mail.Message.
+func (msg *Message) Export() *mail.Message {
+	w := newMessageWriter(msg)
+
+	if msg.hasMixedPart() {
+		w.openMultipart("mixed")
+	}
+
+	if msg.hasRelatedPart() {
+		w.openMultipart("related")
+	}
+
+	if msg.hasAlternativePart() {
+		w.openMultipart("alternative")
+	}
+	for _, part := range msg.parts {
+		h := make(map[string][]string)
+		h["Content-Type"] = []string{part.contentType + "; charset=" + msg.charset}
+		h["Content-Transfer-Encoding"] = []string{string(msg.encoding)}
+
+		w.write(h, part.body.Bytes(), msg.encoding)
+	}
+	if msg.hasAlternativePart() {
+		w.closeMultipart()
+	}
+
+	w.addFiles(msg.embedded, false)
+	if msg.hasRelatedPart() {
+		w.closeMultipart()
+	}
+
+	w.addFiles(msg.attachments, true)
+	if msg.hasMixedPart() {
+		w.closeMultipart()
+	}
+
+	return w.export()
+}
+
+func (msg *Message) hasMixedPart() bool {
+	return (len(msg.parts) > 0 && len(msg.attachments) > 0) || len(msg.attachments) > 1
+}
+
+func (msg *Message) hasRelatedPart() bool {
+	return (len(msg.parts) > 0 && len(msg.embedded) > 0) || len(msg.embedded) > 1
+}
+
+func (msg *Message) hasAlternativePart() bool {
+	return len(msg.parts) > 1
+}
+
+// messageWriter helps converting the message into a net/mail.Message
+type messageWriter struct {
+	header     map[string][]string
+	buf        *bytes.Buffer
+	writers    [3]*multipart.Writer
+	partWriter io.Writer
+	depth      uint8
+}
+
+func newMessageWriter(msg *Message) *messageWriter {
+	// We copy the header so Export does not modify the message
+	header := make(map[string][]string, len(msg.header)+2)
+	for k, v := range msg.header {
+		header[k] = v
+	}
+
+	if _, ok := header["Mime-Version"]; !ok {
+		header["Mime-Version"] = []string{"1.0"}
+	}
+	if _, ok := header["Date"]; !ok {
+		header["Date"] = []string{msg.FormatDate(now())}
+	}
+
+	return &messageWriter{header: header, buf: new(bytes.Buffer)}
+}
+
+// Stubbed out for testing.
+var now = time.Now
+
+func (w *messageWriter) openMultipart(mimeType string) {
+	w.writers[w.depth] = multipart.NewWriter(w.buf)
+	contentType := "multipart/" + mimeType + "; boundary=" + w.writers[w.depth].Boundary()
+
+	if w.depth == 0 {
+		w.header["Content-Type"] = []string{contentType}
+	} else {
+		h := make(map[string][]string)
+		h["Content-Type"] = []string{contentType}
+		w.createPart(h)
+	}
+	w.depth++
+}
+
+func (w *messageWriter) createPart(h map[string][]string) {
+	// No need to check the error since the underlying writer is a bytes.Buffer
+	w.partWriter, _ = w.writers[w.depth-1].CreatePart(h)
+}
+
+func (w *messageWriter) closeMultipart() {
+	if w.depth > 0 {
+		w.writers[w.depth-1].Close()
+		w.depth--
+	}
+}
+
+func (w *messageWriter) addFiles(files []*File, isAttachment bool) {
+	for _, f := range files {
+		h := make(map[string][]string)
+		h["Content-Type"] = []string{f.MimeType + "; name=\"" + f.Name + "\""}
+		h["Content-Transfer-Encoding"] = []string{string(Base64)}
+		if isAttachment {
+			h["Content-Disposition"] = []string{"attachment; filename=\"" + f.Name + "\""}
+		} else {
+			h["Content-Disposition"] = []string{"inline; filename=\"" + f.Name + "\""}
+			if f.ContentID != "" {
+				h["Content-ID"] = []string{"<" + f.ContentID + ">"}
+			} else {
+				h["Content-ID"] = []string{"<" + f.Name + ">"}
+			}
+		}
+
+		w.write(h, f.Content, Base64)
+	}
+}
+
+func (w *messageWriter) write(h map[string][]string, body []byte, enc Encoding) {
+	w.writeHeader(h)
+	w.writeBody(body, enc)
+}
+
+func (w *messageWriter) writeHeader(h map[string][]string) {
+	if w.depth == 0 {
+		for field, value := range h {
+			w.header[field] = value
+		}
+	} else {
+		w.createPart(h)
+	}
+}
+
+func (w *messageWriter) writeBody(body []byte, enc Encoding) {
+	var subWriter io.Writer
+	if w.depth == 0 {
+		subWriter = w.buf
+	} else {
+		subWriter = w.partWriter
+	}
+
+	// The errors returned by writers are not checked since these writers cannot
+	// return errors.
+	if enc == Base64 {
+		writer := base64.NewEncoder(base64.StdEncoding, newBase64LineWriter(subWriter))
+		writer.Write(body)
+		writer.Close()
+	} else if enc == Unencoded {
+		subWriter.Write(body)
+	} else {
+		writer := quotedprintable.NewEncoder(newQpLineWriter(subWriter))
+		writer.Write(body)
+	}
+}
+
+func (w *messageWriter) export() *mail.Message {
+	return &mail.Message{Header: w.header, Body: w.buf}
+}
+
+// As required by RFC 2045, 6.7. (page 21) for quoted-printable, and
+// RFC 2045, 6.8. (page 25) for base64.
+const maxLineLen = 76
+
+// base64LineWriter limits text encoded in base64 to 76 characters per line
+type base64LineWriter struct {
+	w       io.Writer
+	lineLen int
+}
+
+func newBase64LineWriter(w io.Writer) *base64LineWriter {
+	return &base64LineWriter{w: w}
+}
+
+func (w *base64LineWriter) Write(p []byte) (int, error) {
+	n := 0
+	for len(p)+w.lineLen > maxLineLen {
+		w.w.Write(p[:maxLineLen-w.lineLen])
+		w.w.Write([]byte("\r\n"))
+		p = p[maxLineLen-w.lineLen:]
+		n += maxLineLen - w.lineLen
+		w.lineLen = 0
+	}
+
+	w.w.Write(p)
+	w.lineLen += len(p)
+
+	return n + len(p), nil
+}
+
+// qpLineWriter limits text encoded in quoted-printable to 76 characters per
+// line
+type qpLineWriter struct {
+	w       io.Writer
+	lineLen int
+}
+
+func newQpLineWriter(w io.Writer) *qpLineWriter {
+	return &qpLineWriter{w: w}
+}
+
+func (w *qpLineWriter) Write(p []byte) (int, error) {
+	n := 0
+	for len(p) > 0 {
+		// If the text is not over the limit, write everything
+		if len(p) < maxLineLen-w.lineLen {
+			w.w.Write(p)
+			w.lineLen += len(p)
+			return n + len(p), nil
+		}
+
+		i := bytes.IndexAny(p[:maxLineLen-w.lineLen+2], "\n")
+		// If there is a newline before the limit, write the end of the line
+		if i != -1 && (i != maxLineLen-w.lineLen+1 || p[i-1] == '\r') {
+			w.w.Write(p[:i+1])
+			p = p[i+1:]
+			n += i + 1
+			w.lineLen = 0
+			continue
+		}
+
+		// Quoted-printable text must not be cut between an equal sign and the
+		// two following characters
+		var toWrite int
+		if maxLineLen-w.lineLen-2 >= 0 && p[maxLineLen-w.lineLen-2] == '=' {
+			toWrite = maxLineLen - w.lineLen - 2
+		} else if p[maxLineLen-w.lineLen-1] == '=' {
+			toWrite = maxLineLen - w.lineLen - 1
+		} else {
+			toWrite = maxLineLen - w.lineLen
+		}
+
+		// Insert the newline where it is needed
+		w.w.Write(p[:toWrite])
+		w.w.Write([]byte("=\r\n"))
+		p = p[toWrite:]
+		n += toWrite
+		w.lineLen = 0
+	}
+
+	return n, nil
+}
diff --git a/go/src/gopkg.in/gomail.v1/gomail.go b/go/src/gopkg.in/gomail.v1/gomail.go
new file mode 100644
index 0000000..734d881
--- /dev/null
+++ b/go/src/gopkg.in/gomail.v1/gomail.go
@@ -0,0 +1,334 @@
+// Package gomail provides a simple interface to send emails.
+//
+// More info on Github: https://github.com/go-gomail/gomail
+package gomail
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+	"mime"
+	"path/filepath"
+	"sync"
+	"time"
+
+	"gopkg.in/alexcesaro/quotedprintable.v2"
+)
+
+// Message represents an email.
+type Message struct {
+	header      header
+	parts       []part
+	attachments []*File
+	embedded    []*File
+	charset     string
+	encoding    Encoding
+	hEncoder    *quotedprintable.HeaderEncoder
+}
+
+type header map[string][]string
+
+type part struct {
+	contentType string
+	body        *bytes.Buffer
+}
+
+// NewMessage creates a new message. It uses UTF-8 and quoted-printable encoding
+// by default.
+func NewMessage(settings ...MessageSetting) *Message {
+	msg := &Message{
+		header:   make(header),
+		charset:  "UTF-8",
+		encoding: QuotedPrintable,
+	}
+
+	msg.applySettings(settings)
+
+	var e quotedprintable.Encoding
+	if msg.encoding == Base64 {
+		e = quotedprintable.B
+	} else {
+		e = quotedprintable.Q
+	}
+	msg.hEncoder = e.NewHeaderEncoder(msg.charset)
+
+	return msg
+}
+
+func (msg *Message) applySettings(settings []MessageSetting) {
+	for _, s := range settings {
+		s(msg)
+	}
+}
+
+// A MessageSetting can be used as an argument in NewMessage to configure an
+// email.
+type MessageSetting func(msg *Message)
+
+// SetCharset is a message setting to set the charset of the email.
+//
+// Example:
+//
+//	msg := gomail.NewMessage(SetCharset("ISO-8859-1"))
+func SetCharset(charset string) MessageSetting {
+	return func(msg *Message) {
+		msg.charset = charset
+	}
+}
+
+// SetEncoding is a message setting to set the encoding of the email.
+//
+// Example:
+//
+//	msg := gomail.NewMessage(SetEncoding(gomail.Base64))
+func SetEncoding(enc Encoding) MessageSetting {
+	return func(msg *Message) {
+		msg.encoding = enc
+	}
+}
+
+// Encoding represents a MIME encoding scheme like quoted-printable or base64.
+type Encoding string
+
+const (
+	// QuotedPrintable represents the quoted-printable encoding as defined in
+	// RFC 2045.
+	QuotedPrintable Encoding = "quoted-printable"
+	// Base64 represents the base64 encoding as defined in RFC 2045.
+	Base64 Encoding = "base64"
+	// Unencoded can be used to avoid encoding the body of an email. The headers
+	// will still be encoded using quoted-printable encoding.
+	Unencoded Encoding = "8bit"
+)
+
+// SetHeader sets a value to the given header field.
+func (msg *Message) SetHeader(field string, value ...string) {
+	for i := range value {
+		value[i] = encodeHeader(msg.hEncoder, value[i])
+	}
+	msg.header[field] = value
+}
+
+// SetHeaders sets the message headers.
+//
+// Example:
+//
+//	msg.SetHeaders(map[string][]string{
+//		"From":    {"alex@example.com"},
+//		"To":      {"bob@example.com", "cora@example.com"},
+//		"Subject": {"Hello"},
+//	})
+func (msg *Message) SetHeaders(h map[string][]string) {
+	for k, v := range h {
+		msg.SetHeader(k, v...)
+	}
+}
+
+// SetAddressHeader sets an address to the given header field.
+func (msg *Message) SetAddressHeader(field, address, name string) {
+	msg.header[field] = []string{msg.FormatAddress(address, name)}
+}
+
+// FormatAddress formats an address and a name as a valid RFC 5322 address.
+func (msg *Message) FormatAddress(address, name string) string {
+	buf := getBuffer()
+	defer putBuffer(buf)
+
+	if !quotedprintable.NeedsEncoding(name) {
+		quote(buf, name)
+	} else {
+		var n string
+		if hasSpecials(name) {
+			n = encodeHeader(quotedprintable.B.NewHeaderEncoder(msg.charset), name)
+		} else {
+			n = encodeHeader(msg.hEncoder, name)
+		}
+		buf.WriteString(n)
+	}
+	buf.WriteString(" <")
+	buf.WriteString(address)
+	buf.WriteByte('>')
+
+	return buf.String()
+}
+
+// SetDateHeader sets a date to the given header field.
+func (msg *Message) SetDateHeader(field string, date time.Time) {
+	msg.header[field] = []string{msg.FormatDate(date)}
+}
+
+// FormatDate formats a date as a valid RFC 5322 date.
+func (msg *Message) FormatDate(date time.Time) string {
+	return date.Format(time.RFC1123Z)
+}
+
+// GetHeader gets a header field.
+func (msg *Message) GetHeader(field string) []string {
+	return msg.header[field]
+}
+
+// DelHeader deletes a header field.
+func (msg *Message) DelHeader(field string) {
+	delete(msg.header, field)
+}
+
+// SetBody sets the body of the message.
+func (msg *Message) SetBody(contentType, body string) {
+	msg.parts = []part{
+		part{
+			contentType: contentType,
+			body:        bytes.NewBufferString(body),
+		},
+	}
+}
+
+// AddAlternative adds an alternative body to the message. Commonly used to
+// send HTML emails that default to the plain text version for backward
+// compatibility.
+//
+// Example:
+//
+//	msg.SetBody("text/plain", "Hello!")
+//	msg.AddAlternative("text/html", "<p>Hello!</p>")
+//
+// More info: http://en.wikipedia.org/wiki/MIME#Alternative
+func (msg *Message) AddAlternative(contentType, body string) {
+	msg.parts = append(msg.parts,
+		part{
+			contentType: contentType,
+			body:        bytes.NewBufferString(body),
+		},
+	)
+}
+
+// GetBodyWriter gets a writer that writes to the body. It can be useful with
+// the templates from packages text/template or html/template.
+//
+// Example:
+//
+//	w := msg.GetBodyWriter("text/plain")
+//	t := template.Must(template.New("example").Parse("Hello {{.}}!"))
+//	t.Execute(w, "Bob")
+func (msg *Message) GetBodyWriter(contentType string) io.Writer {
+	buf := new(bytes.Buffer)
+	msg.parts = append(msg.parts,
+		part{
+			contentType: contentType,
+			body:        buf,
+		},
+	)
+
+	return buf
+}
+
+// A File represents a file that can be attached or embedded in an email.
+type File struct {
+	Name      string
+	MimeType  string
+	Content   []byte
+	ContentID string
+}
+
+// OpenFile opens a file on disk to create a gomail.File.
+func OpenFile(filename string) (*File, error) {
+	content, err := readFile(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	f := CreateFile(filepath.Base(filename), content)
+
+	return f, nil
+}
+
+// CreateFile creates a gomail.File from the given name and content.
+func CreateFile(name string, content []byte) *File {
+	mimeType := mime.TypeByExtension(filepath.Ext(name))
+	if mimeType == "" {
+		mimeType = "application/octet-stream"
+	}
+
+	return &File{
+		Name:     name,
+		MimeType: mimeType,
+		Content:  content,
+	}
+}
+
+// Attach attaches the files to the email.
+func (msg *Message) Attach(f ...*File) {
+	if msg.attachments == nil {
+		msg.attachments = f
+	} else {
+		msg.attachments = append(msg.attachments, f...)
+	}
+}
+
+// Embed embeds the images to the email.
+//
+// Example:
+//
+//	f, err := gomail.OpenFile("/tmp/image.jpg")
+//	if err != nil {
+//		panic(err)
+//	}
+//	msg.Embed(f)
+//	msg.SetBody("text/html", `<img src="cid:image.jpg" alt="My image" />`)
+func (msg *Message) Embed(image ...*File) {
+	if msg.embedded == nil {
+		msg.embedded = image
+	} else {
+		msg.embedded = append(msg.embedded, image...)
+	}
+}
+
+// Stubbed out for testing.
+var readFile = ioutil.ReadFile
+
+func quote(buf *bytes.Buffer, text string) {
+	buf.WriteByte('"')
+	for i := 0; i < len(text); i++ {
+		if text[i] == '\\' || text[i] == '"' {
+			buf.WriteByte('\\')
+		}
+		buf.WriteByte(text[i])
+	}
+	buf.WriteByte('"')
+}
+
+func hasSpecials(text string) bool {
+	for i := 0; i < len(text); i++ {
+		switch c := text[i]; c {
+		case '(', ')', '<', '>', '[', ']', ':', ';', '@', '\\', ',', '.', '"':
+			return true
+		}
+	}
+
+	return false
+}
+
+func encodeHeader(enc *quotedprintable.HeaderEncoder, value string) string {
+	if !quotedprintable.NeedsEncoding(value) {
+		return value
+	}
+
+	return enc.Encode(value)
+}
+
+var bufPool = sync.Pool{
+	New: func() interface{} {
+		return new(bytes.Buffer)
+	},
+}
+
+func getBuffer() *bytes.Buffer {
+	return bufPool.Get().(*bytes.Buffer)
+}
+
+func putBuffer(buf *bytes.Buffer) {
+	if buf.Len() > 1024 {
+		return
+	}
+	buf.Reset()
+	bufPool.Put(buf)
+}
diff --git a/go/src/gopkg.in/gomail.v1/gomail_test.go b/go/src/gopkg.in/gomail.v1/gomail_test.go
new file mode 100644
index 0000000..087b7c9
--- /dev/null
+++ b/go/src/gopkg.in/gomail.v1/gomail_test.go
@@ -0,0 +1,639 @@
+package gomail
+
+import (
+	"encoding/base64"
+	"net/smtp"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+)
+
+type message struct {
+	from    string
+	to      []string
+	content string
+}
+
+func TestMessage(t *testing.T) {
+	msg := NewMessage()
+	msg.SetAddressHeader("From", "from@example.com", "Señor From")
+	msg.SetHeader("To", msg.FormatAddress("to@example.com", "Señor To"), "tobis@example.com")
+	msg.SetAddressHeader("Cc", "cc@example.com", "A, B")
+	msg.SetAddressHeader("X-To", "ccbis@example.com", "à, b")
+	msg.SetDateHeader("X-Date", stubNow())
+	msg.SetHeader("X-Date-2", msg.FormatDate(stubNow()))
+	msg.SetHeader("Subject", "¡Hola, señor!")
+	msg.SetHeaders(map[string][]string{
+		"X-Headers": {"Test", "Café"},
+	})
+	msg.SetBody("text/plain", "¡Hola, señor!")
+
+	want := message{
+		from: "from@example.com",
+		to: []string{
+			"to@example.com",
+			"tobis@example.com",
+			"cc@example.com",
+		},
+		content: "From: =?UTF-8?Q?Se=C3=B1or_From?= <from@example.com>\r\n" +
+			"To: =?UTF-8?Q?Se=C3=B1or_To?= <to@example.com>, tobis@example.com\r\n" +
+			"Cc: \"A, B\" <cc@example.com>\r\n" +
+			"X-To: =?UTF-8?B?w6AsIGI=?= <ccbis@example.com>\r\n" +
+			"X-Date: Wed, 25 Jun 2014 17:46:00 +0000\r\n" +
+			"X-Date-2: Wed, 25 Jun 2014 17:46:00 +0000\r\n" +
+			"X-Headers: Test, =?UTF-8?Q?Caf=C3=A9?=\r\n" +
+			"Subject: =?UTF-8?Q?=C2=A1Hola,_se=C3=B1or!?=\r\n" +
+			"Content-Type: text/plain; charset=UTF-8\r\n" +
+			"Content-Transfer-Encoding: quoted-printable\r\n" +
+			"\r\n" +
+			"=C2=A1Hola, se=C3=B1or!",
+	}
+
+	testMessage(t, msg, 0, want)
+}
+
+func TestBodyWriter(t *testing.T) {
+	msg := NewMessage()
+	msg.SetHeader("From", "from@example.com")
+	msg.SetHeader("To", "to@example.com")
+	w := msg.GetBodyWriter("text/plain")
+	w.Write([]byte("Test message"))
+
+	want := message{
+		from: "from@example.com",
+		to:   []string{"to@example.com"},
+		content: "From: from@example.com\r\n" +
+			"To: to@example.com\r\n" +
+			"Content-Type: text/plain; charset=UTF-8\r\n" +
+			"Content-Transfer-Encoding: quoted-printable\r\n" +
+			"\r\n" +
+			"Test message",
+	}
+
+	testMessage(t, msg, 0, want)
+}
+
+func TestCustomMessage(t *testing.T) {
+	msg := NewMessage(SetCharset("ISO-8859-1"), SetEncoding(Base64))
+	msg.SetHeaders(map[string][]string{
+		"From":    {"from@example.com"},
+		"To":      {"to@example.com"},
+		"Subject": {"Café"},
+	})
+	msg.SetBody("text/html", "¡Hola, señor!")
+
+	want := message{
+		from: "from@example.com",
+		to:   []string{"to@example.com"},
+		content: "From: from@example.com\r\n" +
+			"To: to@example.com\r\n" +
+			"Subject: =?ISO-8859-1?B?Q2Fmw6k=?=\r\n" +
+			"Content-Type: text/html; charset=ISO-8859-1\r\n" +
+			"Content-Transfer-Encoding: base64\r\n" +
+			"\r\n" +
+			"wqFIb2xhLCBzZcOxb3Ih",
+	}
+
+	testMessage(t, msg, 0, want)
+}
+
+func TestUnencodedMessage(t *testing.T) {
+	msg := NewMessage(SetEncoding(Unencoded))
+	msg.SetHeaders(map[string][]string{
+		"From":    {"from@example.com"},
+		"To":      {"to@example.com"},
+		"Subject": {"Café"},
+	})
+	msg.SetBody("text/html", "¡Hola, señor!")
+
+	want := message{
+		from: "from@example.com",
+		to:   []string{"to@example.com"},
+		content: "From: from@example.com\r\n" +
+			"To: to@example.com\r\n" +
+			"Subject: =?UTF-8?Q?Caf=C3=A9?=\r\n" +
+			"Content-Type: text/html; charset=UTF-8\r\n" +
+			"Content-Transfer-Encoding: 8bit\r\n" +
+			"\r\n" +
+			"¡Hola, señor!",
+	}
+
+	testMessage(t, msg, 0, want)
+}
+
+func TestRecipients(t *testing.T) {
+	msg := NewMessage()
+	msg.SetHeaders(map[string][]string{
+		"From":    {"from@example.com"},
+		"To":      {"to@example.com"},
+		"Cc":      {"cc@example.com"},
+		"Bcc":     {"bcc1@example.com", "bcc2@example.com"},
+		"Subject": {"Hello!"},
+	})
+	msg.SetBody("text/plain", "Test message")
+
+	want := message{
+		from: "from@example.com",
+		to:   []string{"to@example.com", "cc@example.com"},
+		content: "From: from@example.com\r\n" +
+			"To: to@example.com\r\n" +
+			"Cc: cc@example.com\r\n" +
+			"Subject: Hello!\r\n" +
+			"Content-Type: text/plain; charset=UTF-8\r\n" +
+			"Content-Transfer-Encoding: quoted-printable\r\n" +
+			"\r\n" +
+			"Test message",
+	}
+	wantBcc1 := message{
+		from: "from@example.com",
+		to:   []string{"bcc1@example.com"},
+		content: "From: from@example.com\r\n" +
+			"To: to@example.com\r\n" +
+			"Cc: cc@example.com\r\n" +
+			"Bcc: bcc1@example.com\r\n" +
+			"Subject: Hello!\r\n" +
+			"Content-Type: text/plain; charset=UTF-8\r\n" +
+			"Content-Transfer-Encoding: quoted-printable\r\n" +
+			"\r\n" +
+			"Test message",
+	}
+	wantBcc2 := message{
+		from: "from@example.com",
+		to:   []string{"bcc2@example.com"},
+		content: "From: from@example.com\r\n" +
+			"To: to@example.com\r\n" +
+			"Cc: cc@example.com\r\n" +
+			"Bcc: bcc2@example.com\r\n" +
+			"Subject: Hello!\r\n" +
+			"Content-Type: text/plain; charset=UTF-8\r\n" +
+			"Content-Transfer-Encoding: quoted-printable\r\n" +
+			"\r\n" +
+			"Test message",
+	}
+
+	testMessage(t, msg, 0, want, wantBcc1, wantBcc2)
+}
+
+func TestAlternative(t *testing.T) {
+	msg := NewMessage()
+	msg.SetHeader("From", "from@example.com")
+	msg.SetHeader("To", "to@example.com")
+	msg.SetBody("text/plain", "¡Hola, señor!")
+	msg.AddAlternative("text/html", "¡<b>Hola</b>, <i>señor</i>!</h1>")
+
+	want := message{
+		from: "from@example.com",
+		to:   []string{"to@example.com"},
+		content: "From: from@example.com\r\n" +
+			"To: to@example.com\r\n" +
+			"Content-Type: multipart/alternative; boundary=_BOUNDARY_1_\r\n" +
+			"\r\n" +
+			"--_BOUNDARY_1_\r\n" +
+			"Content-Type: text/plain; charset=UTF-8\r\n" +
+			"Content-Transfer-Encoding: quoted-printable\r\n" +
+			"\r\n" +
+			"=C2=A1Hola, se=C3=B1or!\r\n" +
+			"--_BOUNDARY_1_\r\n" +
+			"Content-Type: text/html; charset=UTF-8\r\n" +
+			"Content-Transfer-Encoding: quoted-printable\r\n" +
+			"\r\n" +
+			"=C2=A1<b>Hola</b>, <i>se=C3=B1or</i>!</h1>\r\n" +
+			"--_BOUNDARY_1_--\r\n",
+	}
+
+	testMessage(t, msg, 1, want)
+}
+
+func TestAttachmentOnly(t *testing.T) {
+	readFile = func(filename string) ([]byte, error) {
+		return []byte("Content of " + filepath.Base(filename)), nil
+	}
+
+	msg := NewMessage()
+	msg.SetHeader("From", "from@example.com")
+	msg.SetHeader("To", "to@example.com")
+	f, err := OpenFile("/tmp/test.pdf")
+	if err != nil {
+		panic(err)
+	}
+	msg.Attach(f)
+
+	want := message{
+		from: "from@example.com",
+		to:   []string{"to@example.com"},
+		content: "From: from@example.com\r\n" +
+			"To: to@example.com\r\n" +
+			"Content-Type: application/pdf; name=\"test.pdf\"\r\n" +
+			"Content-Disposition: attachment; filename=\"test.pdf\"\r\n" +
+			"Content-Transfer-Encoding: base64\r\n" +
+			"\r\n" +
+			base64.StdEncoding.EncodeToString([]byte("Content of test.pdf")),
+	}
+
+	testMessage(t, msg, 0, want)
+}
+
+func TestAttachment(t *testing.T) {
+	msg := NewMessage()
+	msg.SetHeader("From", "from@example.com")
+	msg.SetHeader("To", "to@example.com")
+	msg.SetBody("text/plain", "Test")
+	msg.Attach(CreateFile("test.pdf", []byte("Content")))
+
+	want := message{
+		from: "from@example.com",
+		to:   []string{"to@example.com"},
+		content: "From: from@example.com\r\n" +
+			"To: to@example.com\r\n" +
+			"Content-Type: multipart/mixed; boundary=_BOUNDARY_1_\r\n" +
+			"\r\n" +
+			"--_BOUNDARY_1_\r\n" +
+			"Content-Type: text/plain; charset=UTF-8\r\n" +
+			"Content-Transfer-Encoding: quoted-printable\r\n" +
+			"\r\n" +
+			"Test\r\n" +
+			"--_BOUNDARY_1_\r\n" +
+			"Content-Type: application/pdf; name=\"test.pdf\"\r\n" +
+			"Content-Disposition: attachment; filename=\"test.pdf\"\r\n" +
+			"Content-Transfer-Encoding: base64\r\n" +
+			"\r\n" +
+			base64.StdEncoding.EncodeToString([]byte("Content")) + "\r\n" +
+			"--_BOUNDARY_1_--\r\n",
+	}
+
+	testMessage(t, msg, 1, want)
+}
+
+func TestAttachmentsOnly(t *testing.T) {
+	msg := NewMessage()
+	msg.SetHeader("From", "from@example.com")
+	msg.SetHeader("To", "to@example.com")
+	msg.Attach(CreateFile("test.pdf", []byte("Content 1")))
+	msg.Attach(CreateFile("test.zip", []byte("Content 2")))
+
+	want := message{
+		from: "from@example.com",
+		to:   []string{"to@example.com"},
+		content: "From: from@example.com\r\n" +
+			"To: to@example.com\r\n" +
+			"Content-Type: multipart/mixed; boundary=_BOUNDARY_1_\r\n" +
+			"\r\n" +
+			"--_BOUNDARY_1_\r\n" +
+			"Content-Type: application/pdf; name=\"test.pdf\"\r\n" +
+			"Content-Disposition: attachment; filename=\"test.pdf\"\r\n" +
+			"Content-Transfer-Encoding: base64\r\n" +
+			"\r\n" +
+			base64.StdEncoding.EncodeToString([]byte("Content 1")) + "\r\n" +
+			"--_BOUNDARY_1_\r\n" +
+			"Content-Type: application/zip; name=\"test.zip\"\r\n" +
+			"Content-Disposition: attachment; filename=\"test.zip\"\r\n" +
+			"Content-Transfer-Encoding: base64\r\n" +
+			"\r\n" +
+			base64.StdEncoding.EncodeToString([]byte("Content 2")) + "\r\n" +
+			"--_BOUNDARY_1_--\r\n",
+	}
+
+	testMessage(t, msg, 1, want)
+}
+
+func TestAttachments(t *testing.T) {
+	msg := NewMessage()
+	msg.SetHeader("From", "from@example.com")
+	msg.SetHeader("To", "to@example.com")
+	msg.SetBody("text/plain", "Test")
+	msg.Attach(CreateFile("test.pdf", []byte("Content 1")))
+	msg.Attach(CreateFile("test.zip", []byte("Content 2")))
+
+	want := message{
+		from: "from@example.com",
+		to:   []string{"to@example.com"},
+		content: "From: from@example.com\r\n" +
+			"To: to@example.com\r\n" +
+			"Content-Type: multipart/mixed; boundary=_BOUNDARY_1_\r\n" +
+			"\r\n" +
+			"--_BOUNDARY_1_\r\n" +
+			"Content-Type: text/plain; charset=UTF-8\r\n" +
+			"Content-Transfer-Encoding: quoted-printable\r\n" +
+			"\r\n" +
+			"Test\r\n" +
+			"--_BOUNDARY_1_\r\n" +
+			"Content-Type: application/pdf; name=\"test.pdf\"\r\n" +
+			"Content-Disposition: attachment; filename=\"test.pdf\"\r\n" +
+			"Content-Transfer-Encoding: base64\r\n" +
+			"\r\n" +
+			base64.StdEncoding.EncodeToString([]byte("Content 1")) + "\r\n" +
+			"--_BOUNDARY_1_\r\n" +
+			"Content-Type: application/zip; name=\"test.zip\"\r\n" +
+			"Content-Disposition: attachment; filename=\"test.zip\"\r\n" +
+			"Content-Transfer-Encoding: base64\r\n" +
+			"\r\n" +
+			base64.StdEncoding.EncodeToString([]byte("Content 2")) + "\r\n" +
+			"--_BOUNDARY_1_--\r\n",
+	}
+
+	testMessage(t, msg, 1, want)
+}
+
+func TestEmbedded(t *testing.T) {
+	msg := NewMessage()
+	msg.SetHeader("From", "from@example.com")
+	msg.SetHeader("To", "to@example.com")
+	f := CreateFile("image1.jpg", []byte("Content 1"))
+	f.ContentID = "test-content-id"
+	msg.Embed(f)
+	msg.Embed(CreateFile("image2.jpg", []byte("Content 2")))
+	msg.SetBody("text/plain", "Test")
+
+	want := message{
+		from: "from@example.com",
+		to:   []string{"to@example.com"},
+		content: "From: from@example.com\r\n" +
+			"To: to@example.com\r\n" +
+			"Content-Type: multipart/related; boundary=_BOUNDARY_1_\r\n" +
+			"\r\n" +
+			"--_BOUNDARY_1_\r\n" +
+			"Content-Type: text/plain; charset=UTF-8\r\n" +
+			"Content-Transfer-Encoding: quoted-printable\r\n" +
+			"\r\n" +
+			"Test\r\n" +
+			"--_BOUNDARY_1_\r\n" +
+			"Content-Type: image/jpeg; name=\"image1.jpg\"\r\n" +
+			"Content-Disposition: inline; filename=\"image1.jpg\"\r\n" +
+			"Content-ID: <test-content-id>\r\n" +
+			"Content-Transfer-Encoding: base64\r\n" +
+			"\r\n" +
+			base64.StdEncoding.EncodeToString([]byte("Content 1")) + "\r\n" +
+			"--_BOUNDARY_1_\r\n" +
+			"Content-Type: image/jpeg; name=\"image2.jpg\"\r\n" +
+			"Content-Disposition: inline; filename=\"image2.jpg\"\r\n" +
+			"Content-ID: <image2.jpg>\r\n" +
+			"Content-Transfer-Encoding: base64\r\n" +
+			"\r\n" +
+			base64.StdEncoding.EncodeToString([]byte("Content 2")) + "\r\n" +
+			"--_BOUNDARY_1_--\r\n",
+	}
+
+	testMessage(t, msg, 1, want)
+}
+
+func TestFullMessage(t *testing.T) {
+	msg := NewMessage()
+	msg.SetHeader("From", "from@example.com")
+	msg.SetHeader("To", "to@example.com")
+	msg.SetBody("text/plain", "¡Hola, señor!")
+	msg.AddAlternative("text/html", "¡<b>Hola</b>, <i>señor</i>!</h1>")
+	msg.Attach(CreateFile("test.pdf", []byte("Content 1")))
+	msg.Embed(CreateFile("image.jpg", []byte("Content 2")))
+
+	want := message{
+		from: "from@example.com",
+		to:   []string{"to@example.com"},
+		content: "From: from@example.com\r\n" +
+			"To: to@example.com\r\n" +
+			"Content-Type: multipart/mixed; boundary=_BOUNDARY_1_\r\n" +
+			"\r\n" +
+			"--_BOUNDARY_1_\r\n" +
+			"Content-Type: multipart/related; boundary=_BOUNDARY_2_\r\n" +
+			"\r\n" +
+			"--_BOUNDARY_2_\r\n" +
+			"Content-Type: multipart/alternative; boundary=_BOUNDARY_3_\r\n" +
+			"\r\n" +
+			"--_BOUNDARY_3_\r\n" +
+			"Content-Type: text/plain; charset=UTF-8\r\n" +
+			"Content-Transfer-Encoding: quoted-printable\r\n" +
+			"\r\n" +
+			"=C2=A1Hola, se=C3=B1or!\r\n" +
+			"--_BOUNDARY_3_\r\n" +
+			"Content-Type: text/html; charset=UTF-8\r\n" +
+			"Content-Transfer-Encoding: quoted-printable\r\n" +
+			"\r\n" +
+			"=C2=A1<b>Hola</b>, <i>se=C3=B1or</i>!</h1>\r\n" +
+			"--_BOUNDARY_3_--\r\n" +
+			"\r\n" +
+			"--_BOUNDARY_2_\r\n" +
+			"Content-Type: image/jpeg; name=\"image.jpg\"\r\n" +
+			"Content-Disposition: inline; filename=\"image.jpg\"\r\n" +
+			"Content-ID: <image.jpg>\r\n" +
+			"Content-Transfer-Encoding: base64\r\n" +
+			"\r\n" +
+			base64.StdEncoding.EncodeToString([]byte("Content 2")) + "\r\n" +
+			"--_BOUNDARY_2_--\r\n" +
+			"\r\n" +
+			"--_BOUNDARY_1_\r\n" +
+			"Content-Type: application/pdf; name=\"test.pdf\"\r\n" +
+			"Content-Disposition: attachment; filename=\"test.pdf\"\r\n" +
+			"Content-Transfer-Encoding: base64\r\n" +
+			"\r\n" +
+			base64.StdEncoding.EncodeToString([]byte("Content 1")) + "\r\n" +
+			"--_BOUNDARY_1_--\r\n",
+	}
+
+	testMessage(t, msg, 3, want)
+}
+
+func TestQpLineLength(t *testing.T) {
+	msg := NewMessage()
+	msg.SetHeader("From", "from@example.com")
+	msg.SetHeader("To", "to@example.com")
+	msg.SetBody("text/plain",
+		strings.Repeat("0", 77)+"\r\n"+
+			strings.Repeat("0", 76)+"à\r\n"+
+			strings.Repeat("0", 75)+"à\r\n"+
+			strings.Repeat("0", 74)+"à\r\n"+
+			strings.Repeat("0", 73)+"à\r\n"+
+			strings.Repeat("0", 76)+"\r\n"+
+			strings.Repeat("0", 77)+"\n")
+
+	want := message{
+		from: "from@example.com",
+		to:   []string{"to@example.com"},
+		content: "From: from@example.com\r\n" +
+			"To: to@example.com\r\n" +
+			"Content-Type: text/plain; charset=UTF-8\r\n" +
+			"Content-Transfer-Encoding: quoted-printable\r\n" +
+			"\r\n" +
+			strings.Repeat("0", 76) + "=\r\n0\r\n" +
+			strings.Repeat("0", 76) + "=\r\n=C3=A0\r\n" +
+			strings.Repeat("0", 75) + "=\r\n=C3=A0\r\n" +
+			strings.Repeat("0", 74) + "=\r\n=C3=A0\r\n" +
+			strings.Repeat("0", 73) + "=C3=\r\n=A0\r\n" +
+			strings.Repeat("0", 76) + "\r\n" +
+			strings.Repeat("0", 76) + "=\r\n0\n",
+	}
+
+	testMessage(t, msg, 0, want)
+}
+
+func TestBase64LineLength(t *testing.T) {
+	msg := NewMessage(SetCharset("UTF-8"), SetEncoding(Base64))
+	msg.SetHeader("From", "from@example.com")
+	msg.SetHeader("To", "to@example.com")
+	msg.SetBody("text/plain", strings.Repeat("0", 58))
+
+	want := message{
+		from: "from@example.com",
+		to:   []string{"to@example.com"},
+		content: "From: from@example.com\r\n" +
+			"To: to@example.com\r\n" +
+			"Content-Type: text/plain; charset=UTF-8\r\n" +
+			"Content-Transfer-Encoding: base64\r\n" +
+			"\r\n" +
+			strings.Repeat("MDAw", 19) + "\r\nMA==",
+	}
+
+	testMessage(t, msg, 0, want)
+}
+
+func testMessage(t *testing.T, msg *Message, bCount int, emails ...message) {
+	now = stubNow
+	mailer := NewMailer("host", "username", "password", 587, SetSendMail(stubSendMail(t, bCount, emails...)))
+
+	err := mailer.Send(msg)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func stubNow() time.Time {
+	return time.Date(2014, 06, 25, 17, 46, 0, 0, time.UTC)
+}
+
+func stubSendMail(t *testing.T, bCount int, emails ...message) SendMailFunc {
+	i := 0
+	return func(addr string, a smtp.Auth, from string, to []string, msg []byte) error {
+		if i > len(emails) {
+			t.Fatalf("Only %d mails should be sent", len(emails))
+		}
+		want := emails[i]
+
+		if addr != "host:587" {
+			t.Fatalf("Invalid address, got %q, want host:587", addr)
+		}
+
+		if from != want.from {
+			t.Fatalf("Invalid from, got %q, want %q", from, want.from)
+		}
+
+		if len(to) != len(want.to) {
+			t.Fatalf("Invalid recipient count, \ngot %d: %q\nwant %d: %q",
+				len(to), to,
+				len(want.to), want.to,
+			)
+		}
+		for i := range want.to {
+			if to[i] != want.to[i] {
+				t.Fatalf("Invalid recipient, got %q, want %q",
+					to[i], want.to[i],
+				)
+			}
+		}
+
+		got := string(msg)
+		wantMsg := string("Mime-Version: 1.0\r\n" +
+			"Date: Wed, 25 Jun 2014 17:46:00 +0000\r\n" +
+			want.content)
+		if bCount > 0 {
+			boundaries := getBoundaries(t, bCount, got)
+			for i, b := range boundaries {
+				wantMsg = strings.Replace(wantMsg, "_BOUNDARY_"+strconv.Itoa(i+1)+"_", b, -1)
+			}
+		}
+		i++
+
+		compareBodies(t, got, wantMsg)
+
+		return nil
+	}
+}
+
+func compareBodies(t *testing.T, got, want string) {
+	// We cannot do a simple comparison since the ordering of headers' fields
+	// is random.
+	gotLines := strings.Split(got, "\r\n")
+	wantLines := strings.Split(want, "\r\n")
+
+	// We only test for too many lines, missing lines are tested after
+	if len(gotLines) > len(wantLines) {
+		t.Fatalf("Message has too many lines, \ngot %d:\n%s\nwant %d:\n%s", len(gotLines), got, len(wantLines), want)
+	}
+
+	isInHeader := true
+	headerStart := 0
+	for i, line := range wantLines {
+		if line == gotLines[i] {
+			if line == "" {
+				isInHeader = false
+			} else if !isInHeader && len(line) > 2 && line[:2] == "--" {
+				isInHeader = true
+				headerStart = i + 1
+			}
+			continue
+		}
+
+		if !isInHeader {
+			missingLine(t, line, got, want)
+		}
+
+		isMissing := true
+		for j := headerStart; j < len(gotLines); j++ {
+			if gotLines[j] == "" {
+				break
+			}
+			if gotLines[j] == line {
+				isMissing = false
+				break
+			}
+		}
+		if isMissing {
+			missingLine(t, line, got, want)
+		}
+	}
+}
+
+func missingLine(t *testing.T, line, got, want string) {
+	t.Fatalf("Missing line %q\ngot:\n%s\nwant:\n%s", line, got, want)
+}
+
+func getBoundaries(t *testing.T, count int, msg string) []string {
+	if matches := boundaryRegExp.FindAllStringSubmatch(msg, count); matches != nil {
+		boundaries := make([]string, count)
+		for i, match := range matches {
+			boundaries[i] = match[1]
+		}
+		return boundaries
+	}
+
+	t.Fatal("Boundary not found in body")
+	return []string{""}
+}
+
+var boundaryRegExp = regexp.MustCompile("boundary=(\\w+)")
+
+func BenchmarkFull(b *testing.B) {
+	emptyFunc := func(addr string, a smtp.Auth, from string, to []string, msg []byte) error {
+		return nil
+	}
+
+	for n := 0; n < b.N; n++ {
+		msg := NewMessage()
+		msg.SetAddressHeader("From", "from@example.com", "Señor From")
+		msg.SetHeaders(map[string][]string{
+			"To":      {"to@example.com"},
+			"Cc":      {"cc@example.com"},
+			"Bcc":     {"bcc1@example.com", "bcc2@example.com"},
+			"Subject": {"¡Hola, señor!"},
+		})
+		msg.SetBody("text/plain", "¡Hola, señor!")
+		msg.AddAlternative("text/html", "<p>¡Hola, señor!</p>")
+		msg.Attach(CreateFile("benchmark.txt", []byte("Benchmark")))
+		msg.Embed(CreateFile("benchmark.jpg", []byte("Benchmark")))
+
+		mailer := NewMailer("host", "username", "password", 587, SetSendMail(emptyFunc))
+		if err := mailer.Send(msg); err != nil {
+			panic(err)
+		}
+	}
+}
diff --git a/go/src/gopkg.in/gomail.v1/login.go b/go/src/gopkg.in/gomail.v1/login.go
new file mode 100644
index 0000000..ee4b3b4
--- /dev/null
+++ b/go/src/gopkg.in/gomail.v1/login.go
@@ -0,0 +1,54 @@
+package gomail
+
+import (
+	"errors"
+	"fmt"
+	"net/smtp"
+	"strings"
+)
+
+type loginAuth struct {
+	username string
+	password string
+	host     string
+}
+
+// LoginAuth returns an Auth that implements the LOGIN authentication mechanism.
+func LoginAuth(username, password, host string) smtp.Auth {
+	return &loginAuth{username, password, host}
+}
+
+func (a *loginAuth) Start(server *smtp.ServerInfo) (string, []byte, error) {
+	if !server.TLS {
+		advertised := false
+		for _, mechanism := range server.Auth {
+			if mechanism == "LOGIN" {
+				advertised = true
+				break
+			}
+		}
+		if !advertised {
+			return "", nil, errors.New("gomail: unencrypted connection")
+		}
+	}
+	if server.Name != a.host {
+		return "", nil, errors.New("gomail: wrong host name")
+	}
+	return "LOGIN", nil, nil
+}
+
+func (a *loginAuth) Next(fromServer []byte, more bool) ([]byte, error) {
+	if !more {
+		return nil, nil
+	}
+
+	command := strings.ToLower(strings.TrimSuffix(string(fromServer), ":"))
+	switch command {
+	case "username":
+		return []byte(fmt.Sprintf("%s", a.username)), nil
+	case "password":
+		return []byte(fmt.Sprintf("%s", a.password)), nil
+	default:
+		return nil, fmt.Errorf("gomail: unexpected server challenge: %s", command)
+	}
+}
diff --git a/go/src/gopkg.in/gomail.v1/login_test.go b/go/src/gopkg.in/gomail.v1/login_test.go
new file mode 100644
index 0000000..64e1762
--- /dev/null
+++ b/go/src/gopkg.in/gomail.v1/login_test.go
@@ -0,0 +1,66 @@
+package gomail
+
+import (
+	"net/smtp"
+	"testing"
+)
+
+type output struct {
+	proto string
+	data  []string
+	err   error
+}
+
+const (
+	testUser = "user"
+	testPwd  = "pwd"
+)
+
+func TestPlainAuth(t *testing.T) {
+	tests := []struct {
+		serverProtos     []string
+		serverChallenges []string
+		proto            string
+		data             []string
+	}{
+		{
+			serverProtos:     []string{"LOGIN"},
+			serverChallenges: []string{"Username:", "Password:"},
+			proto:            "LOGIN",
+			data:             []string{"", testUser, testPwd},
+		},
+	}
+
+	for _, test := range tests {
+		auth := LoginAuth(testUser, testPwd, testHost)
+		server := &smtp.ServerInfo{
+			Name: testHost,
+			TLS:  true,
+			Auth: test.serverProtos,
+		}
+		proto, toServer, err := auth.Start(server)
+		if err != nil {
+			t.Fatalf("Start error: %v", err)
+		}
+		if proto != test.proto {
+			t.Errorf("Invalid protocol, got %q, want %q", proto, test.proto)
+		}
+
+		i := 0
+		got := string(toServer)
+		if got != test.data[i] {
+			t.Errorf("Invalid response, got %q, want %q", got, test.data[i])
+		}
+		for _, challenge := range test.serverChallenges {
+			toServer, err = auth.Next([]byte(challenge), true)
+			if err != nil {
+				t.Fatalf("Auth error: %v", err)
+			}
+			i++
+			got = string(toServer)
+			if got != test.data[i] {
+				t.Errorf("Invalid response, got %q, want %q", got, test.data[i])
+			}
+		}
+	}
+}
diff --git a/go/src/gopkg.in/gomail.v1/mailer.go b/go/src/gopkg.in/gomail.v1/mailer.go
new file mode 100644
index 0000000..99ab619
--- /dev/null
+++ b/go/src/gopkg.in/gomail.v1/mailer.go
@@ -0,0 +1,205 @@
+package gomail
+
+import (
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net"
+	"net/mail"
+	"net/smtp"
+	"strings"
+)
+
+// A Mailer represents an SMTP server.
+type Mailer struct {
+	addr   string
+	host   string
+	config *tls.Config
+	auth   smtp.Auth
+	send   SendMailFunc
+}
+
+// A MailerSetting can be used in a mailer constructor to configure it.
+type MailerSetting func(m *Mailer)
+
+// SetSendMail allows to set the email-sending function of a mailer.
+//
+// Example:
+//
+//	myFunc := func(addr string, a smtp.Auth, from string, to []string, msg []byte) error {
+//		// Implement your email-sending function similar to smtp.SendMail
+//	}
+//	mailer := gomail.NewMailer("host", "user", "pwd", 465, SetSendMail(myFunc))
+func SetSendMail(s SendMailFunc) MailerSetting {
+	return func(m *Mailer) {
+		m.send = s
+	}
+}
+
+// SetTLSConfig allows to set the TLS configuration used to connect the SMTP
+// server.
+func SetTLSConfig(c *tls.Config) MailerSetting {
+	return func(m *Mailer) {
+		m.config = c
+	}
+}
+
+// A SendMailFunc is a function to send emails with the same signature than
+// smtp.SendMail.
+type SendMailFunc func(addr string, a smtp.Auth, from string, to []string, msg []byte) error
+
+// NewMailer returns a mailer. The given parameters are used to connect to the
+// SMTP server via a PLAIN authentication mechanism.
+func NewMailer(host string, username string, password string, port int, settings ...MailerSetting) *Mailer {
+	return NewCustomMailer(
+		fmt.Sprintf("%s:%d", host, port),
+		smtp.PlainAuth("", username, password, host),
+		settings...,
+	)
+}
+
+// NewCustomMailer creates a mailer with the given authentication mechanism.
+//
+// Example:
+//
+//	gomail.NewCustomMailer("host:587", smtp.CRAMMD5Auth("username", "secret"))
+func NewCustomMailer(addr string, auth smtp.Auth, settings ...MailerSetting) *Mailer {
+	// Error is not handled here to preserve backward compatibility
+	host, port, _ := net.SplitHostPort(addr)
+
+	m := &Mailer{
+		addr: addr,
+		host: host,
+		auth: auth,
+	}
+
+	for _, s := range settings {
+		s(m)
+	}
+
+	if m.config == nil {
+		m.config = &tls.Config{ServerName: host}
+	}
+	if m.send == nil {
+		m.send = m.getSendMailFunc(port == "465")
+	}
+
+	return m
+}
+
+// Send sends the emails to all the recipients of the message.
+func (m *Mailer) Send(msg *Message) error {
+	message := msg.Export()
+
+	from, err := getFrom(message)
+	if err != nil {
+		return err
+	}
+	recipients, bcc, err := getRecipients(message)
+	if err != nil {
+		return err
+	}
+
+	h := flattenHeader(message, "")
+	body, err := ioutil.ReadAll(message.Body)
+	if err != nil {
+		return err
+	}
+
+	mail := append(h, body...)
+	if err := m.send(m.addr, m.auth, from, recipients, mail); err != nil {
+		return err
+	}
+
+	for _, to := range bcc {
+		h = flattenHeader(message, to)
+		mail = append(h, body...)
+		if err := m.send(m.addr, m.auth, from, []string{to}, mail); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func flattenHeader(msg *mail.Message, bcc string) []byte {
+	buf := getBuffer()
+	defer putBuffer(buf)
+
+	for field, value := range msg.Header {
+		if field != "Bcc" {
+			buf.WriteString(field)
+			buf.WriteString(": ")
+			buf.WriteString(strings.Join(value, ", "))
+			buf.WriteString("\r\n")
+		} else if bcc != "" {
+			for _, to := range value {
+				if strings.Contains(to, bcc) {
+					buf.WriteString(field)
+					buf.WriteString(": ")
+					buf.WriteString(to)
+					buf.WriteString("\r\n")
+				}
+			}
+		}
+	}
+	buf.WriteString("\r\n")
+
+	return buf.Bytes()
+}
+
+func getFrom(msg *mail.Message) (string, error) {
+	from := msg.Header.Get("Sender")
+	if from == "" {
+		from = msg.Header.Get("From")
+		if from == "" {
+			return "", errors.New("mailer: invalid message, \"From\" field is absent")
+		}
+	}
+
+	return parseAddress(from)
+}
+
+func getRecipients(msg *mail.Message) (recipients, bcc []string, err error) {
+	for _, field := range []string{"Bcc", "To", "Cc"} {
+		if addresses, ok := msg.Header[field]; ok {
+			for _, addr := range addresses {
+				switch field {
+				case "Bcc":
+					bcc, err = addAdress(bcc, addr)
+				default:
+					recipients, err = addAdress(recipients, addr)
+				}
+				if err != nil {
+					return recipients, bcc, err
+				}
+			}
+		}
+	}
+
+	return recipients, bcc, nil
+}
+
+func addAdress(list []string, addr string) ([]string, error) {
+	addr, err := parseAddress(addr)
+	if err != nil {
+		return list, err
+	}
+	for _, a := range list {
+		if addr == a {
+			return list, nil
+		}
+	}
+
+	return append(list, addr), nil
+}
+
+func parseAddress(field string) (string, error) {
+	a, err := mail.ParseAddress(field)
+	if a == nil {
+		return "", err
+	}
+
+	return a.Address, err
+}
diff --git a/go/src/gopkg.in/gomail.v1/send.go b/go/src/gopkg.in/gomail.v1/send.go
new file mode 100644
index 0000000..77aa6a2
--- /dev/null
+++ b/go/src/gopkg.in/gomail.v1/send.go
@@ -0,0 +1,102 @@
+package gomail
+
+import (
+	"crypto/tls"
+	"io"
+	"net"
+	"net/smtp"
+)
+
+func (m *Mailer) getSendMailFunc(ssl bool) SendMailFunc {
+	return func(addr string, a smtp.Auth, from string, to []string, msg []byte) error {
+		var c smtpClient
+		var err error
+		if ssl {
+			c, err = sslDial(addr, m.host, m.config)
+		} else {
+			c, err = starttlsDial(addr, m.config)
+		}
+		if err != nil {
+			return err
+		}
+		defer c.Close()
+
+		if a != nil {
+			if ok, _ := c.Extension("AUTH"); ok {
+				if err = c.Auth(a); err != nil {
+					return err
+				}
+			}
+		}
+
+		if err = c.Mail(from); err != nil {
+			return err
+		}
+
+		for _, addr := range to {
+			if err = c.Rcpt(addr); err != nil {
+				return err
+			}
+		}
+
+		w, err := c.Data()
+		if err != nil {
+			return err
+		}
+		_, err = w.Write(msg)
+		if err != nil {
+			return err
+		}
+		err = w.Close()
+		if err != nil {
+			return err
+		}
+
+		return c.Quit()
+	}
+}
+
+func sslDial(addr, host string, config *tls.Config) (smtpClient, error) {
+	conn, err := initTLS("tcp", addr, config)
+	if err != nil {
+		return nil, err
+	}
+
+	return newClient(conn, host)
+}
+
+func starttlsDial(addr string, config *tls.Config) (smtpClient, error) {
+	c, err := initSMTP(addr)
+	if err != nil {
+		return c, err
+	}
+
+	if ok, _ := c.Extension("STARTTLS"); ok {
+		return c, c.StartTLS(config)
+	}
+
+	return c, nil
+}
+
+var initSMTP = func(addr string) (smtpClient, error) {
+	return smtp.Dial(addr)
+}
+
+var initTLS = func(network, addr string, config *tls.Config) (*tls.Conn, error) {
+	return tls.Dial(network, addr, config)
+}
+
+var newClient = func(conn net.Conn, host string) (smtpClient, error) {
+	return smtp.NewClient(conn, host)
+}
+
+type smtpClient interface {
+	Extension(string) (bool, string)
+	StartTLS(*tls.Config) error
+	Auth(smtp.Auth) error
+	Mail(string) error
+	Rcpt(string) error
+	Data() (io.WriteCloser, error)
+	Quit() error
+	Close() error
+}
diff --git a/go/src/gopkg.in/gomail.v1/send_test.go b/go/src/gopkg.in/gomail.v1/send_test.go
new file mode 100644
index 0000000..7f074bc
--- /dev/null
+++ b/go/src/gopkg.in/gomail.v1/send_test.go
@@ -0,0 +1,245 @@
+package gomail
+
+import (
+	"crypto/tls"
+	"io"
+	"net"
+	"net/smtp"
+	"testing"
+)
+
+var (
+	testAddr    = "smtp.example.com:587"
+	testSSLAddr = "smtp.example.com:465"
+	testTLSConn = &tls.Conn{}
+	testConfig  = &tls.Config{InsecureSkipVerify: true}
+	testHost    = "smtp.example.com"
+	testAuth    = smtp.PlainAuth("", "user", "pwd", "smtp.example.com")
+	testFrom    = "from@example.com"
+	testTo      = []string{"to1@example.com", "to2@example.com"}
+	testBody    = "Test message"
+)
+
+const wantMsg = "To: to1@example.com, to2@example.com\r\n" +
+	"From: from@example.com\r\n" +
+	"Mime-Version: 1.0\r\n" +
+	"Date: Wed, 25 Jun 2014 17:46:00 +0000\r\n" +
+	"Content-Type: text/plain; charset=UTF-8\r\n" +
+	"Content-Transfer-Encoding: quoted-printable\r\n" +
+	"\r\n" +
+	"Test message"
+
+func TestDefaultSendMail(t *testing.T) {
+	testSendMail(t, testAddr, nil, []string{
+		"Extension STARTTLS",
+		"StartTLS",
+		"Extension AUTH",
+		"Auth",
+		"Mail " + testFrom,
+		"Rcpt " + testTo[0],
+		"Rcpt " + testTo[1],
+		"Data",
+		"Write message",
+		"Close writer",
+		"Quit",
+		"Close",
+	})
+}
+
+func TestSSLSendMail(t *testing.T) {
+	testSendMail(t, testSSLAddr, nil, []string{
+		"Extension AUTH",
+		"Auth",
+		"Mail " + testFrom,
+		"Rcpt " + testTo[0],
+		"Rcpt " + testTo[1],
+		"Data",
+		"Write message",
+		"Close writer",
+		"Quit",
+		"Close",
+	})
+}
+
+func TestTLSConfigSendMail(t *testing.T) {
+	testSendMail(t, testAddr, testConfig, []string{
+		"Extension STARTTLS",
+		"StartTLS",
+		"Extension AUTH",
+		"Auth",
+		"Mail " + testFrom,
+		"Rcpt " + testTo[0],
+		"Rcpt " + testTo[1],
+		"Data",
+		"Write message",
+		"Close writer",
+		"Quit",
+		"Close",
+	})
+}
+
+func TestTLSConfigSSLSendMail(t *testing.T) {
+	testSendMail(t, testSSLAddr, testConfig, []string{
+		"Extension AUTH",
+		"Auth",
+		"Mail " + testFrom,
+		"Rcpt " + testTo[0],
+		"Rcpt " + testTo[1],
+		"Data",
+		"Write message",
+		"Close writer",
+		"Quit",
+		"Close",
+	})
+}
+
+type mockClient struct {
+	t      *testing.T
+	i      int
+	want   []string
+	addr   string
+	auth   smtp.Auth
+	config *tls.Config
+}
+
+func (c *mockClient) Extension(ext string) (bool, string) {
+	c.do("Extension " + ext)
+	return true, ""
+}
+
+func (c *mockClient) StartTLS(config *tls.Config) error {
+	assertConfig(c.t, config, c.config)
+	c.do("StartTLS")
+	return nil
+}
+
+func (c *mockClient) Auth(a smtp.Auth) error {
+	assertAuth(c.t, a, c.auth)
+	c.do("Auth")
+	return nil
+}
+
+func (c *mockClient) Mail(from string) error {
+	c.do("Mail " + from)
+	return nil
+}
+
+func (c *mockClient) Rcpt(to string) error {
+	c.do("Rcpt " + to)
+	return nil
+}
+
+func (c *mockClient) Data() (io.WriteCloser, error) {
+	c.do("Data")
+	return &mockWriter{c: c, want: wantMsg}, nil
+}
+
+func (c *mockClient) Quit() error {
+	c.do("Quit")
+	return nil
+}
+
+func (c *mockClient) Close() error {
+	c.do("Close")
+	return nil
+}
+
+func (c *mockClient) do(cmd string) {
+	if c.i >= len(c.want) {
+		c.t.Fatalf("Invalid command %q", cmd)
+	}
+
+	if cmd != c.want[c.i] {
+		c.t.Fatalf("Invalid command, got %q, want %q", cmd, c.want[c.i])
+	}
+	c.i++
+}
+
+type mockWriter struct {
+	want string
+	c    *mockClient
+}
+
+func (w *mockWriter) Write(p []byte) (int, error) {
+	w.c.do("Write message")
+	compareBodies(w.c.t, string(p), w.want)
+	return len(p), nil
+}
+
+func (w *mockWriter) Close() error {
+	w.c.do("Close writer")
+	return nil
+}
+
+func testSendMail(t *testing.T, addr string, config *tls.Config, want []string) {
+	testClient := &mockClient{
+		t:      t,
+		want:   want,
+		addr:   addr,
+		auth:   testAuth,
+		config: config,
+	}
+
+	initSMTP = func(addr string) (smtpClient, error) {
+		assertAddr(t, addr, testClient.addr)
+		return testClient, nil
+	}
+
+	initTLS = func(network, addr string, config *tls.Config) (*tls.Conn, error) {
+		if network != "tcp" {
+			t.Errorf("Invalid network, got %q, want tcp", network)
+		}
+		assertAddr(t, addr, testClient.addr)
+		assertConfig(t, config, testClient.config)
+		return testTLSConn, nil
+	}
+
+	newClient = func(conn net.Conn, host string) (smtpClient, error) {
+		if conn != testTLSConn {
+			t.Error("Invalid TLS connection used")
+		}
+		if host != testHost {
+			t.Errorf("Invalid host, got %q, want %q", host, testHost)
+		}
+		return testClient, nil
+	}
+
+	msg := NewMessage()
+	msg.SetHeader("From", testFrom)
+	msg.SetHeader("To", testTo...)
+	msg.SetBody("text/plain", testBody)
+
+	var settings []MailerSetting
+	if config != nil {
+		settings = []MailerSetting{SetTLSConfig(config)}
+	}
+
+	mailer := NewCustomMailer(addr, testAuth, settings...)
+	if err := mailer.Send(msg); err != nil {
+		t.Error(err)
+	}
+}
+
+func assertAuth(t *testing.T, got, want smtp.Auth) {
+	if got != want {
+		t.Errorf("Invalid auth, got %#v, want %#v", got, want)
+	}
+}
+
+func assertAddr(t *testing.T, got, want string) {
+	if got != want {
+		t.Errorf("Invalid addr, got %q, want %q", got, want)
+	}
+}
+
+func assertConfig(t *testing.T, got, want *tls.Config) {
+	if want == nil {
+		want = &tls.Config{ServerName: testHost}
+	}
+	if got.ServerName != want.ServerName {
+		t.Errorf("Invalid field ServerName in config, got %q, want %q", got.ServerName, want.ServerName)
+	}
+	if got.InsecureSkipVerify != want.InsecureSkipVerify {
+		t.Errorf("Invalid field InsecureSkipVerify in config, got %v, want %v", got.InsecureSkipVerify, want.InsecureSkipVerify)
+	}
+}