сделал gpt4

2025-11-28 23:20:10 +02:00 · 2023-05-02 09:44:46 +03:00
parent 66e89131a4
commit 58704c2a28
346 changed files with 26612 additions and 4615 deletions
--- a/.env_empty
+++ b/.env_empty
@@ -37,4 +37,16 @@ WHATSAPP_PHONE_SEND_TEST=
 CHATGPT_API_KEY=
 CHATGPT_NAME=
 CHATGPT_START_TEXT=
-CHATGPT_END_TEXT=
+CHATGPT_END_TEXT=
+
+EMAIL_SMTP_SERVER=""
+EMAIL_POP3_SERVER=""
+EMAIL_IMAP_SERVER=""
+EMAIL_SMTP_PORT=""
+EMAIL_POP3_PORT=""
+EMAIL_IMAP_PORT=""
+EMAIL_LOGIN=
+EMAIL_PASSWORD=
+EMAIL_SEND_TO_TEST=
+EMAIL_AUTHENTICATION="" #AuthNone, AuthLogin, AuthPlain, AuthCRAMMD5
+EMAIL_ENCRYPTION="" #EncryptionNone, EncryptionSSL, EncryptionSSLTLS, EncryptionSTARTTLS, EncryptionTLS
--- a/2
+++ b/2
@@ -1,5 +1,5 @@
 SERVICEURL=gitlab.aescorp.ru/dsp_dev/claim/nikitin
-SERVICEURL2=gitlab.aescorp.ru/dsp_dev/claim/nikitin
+SERVICEURL2=github.com/manyakrus/starter

 FILEMAIN=./internal/v0/app/main.go
 FILEAPP=./bin/app_race
--- a/chatgpt_connect/chatgpt_connect.go
+++ b/chatgpt_connect/chatgpt_connect.go
@@ -14,7 +14,7 @@ import (
 	"github.com/manyakrus/starter/contextmain"
 	"github.com/manyakrus/starter/stopapp"

-	gogpt "github.com/sashabaranov/go-gpt3"
+	gogpt "github.com/sashabaranov/go-openai"
 )

 // Conn - соединение к CHAT GPT
@@ -181,7 +181,7 @@ func SendMessage(Text string, user string) (string, error) {
 	defer cancel()

 	req := gogpt.CompletionRequest{
-		Model:     gogpt.GPT3TextDavinci003, //надо gogpt.GPT3TextDavinci003
+		Model:     gogpt.GPT4, //надо gogpt.GPT3TextDavinci003
 		MaxTokens: 2048,
 		Prompt:    Text,
 		User:      user,
--- a/email/email.go
+++ b/email/email.go
@@ -0,0 +1,357 @@
+// модуль для отправки email сообщений
+
+package email
+
+//License:
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/joho/godotenv"
+	"github.com/manyakrus/starter/micro"
+	"os"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/manyakrus/starter/contextmain"
+	"github.com/manyakrus/starter/logger"
+	//"github.com/manyakrus/starter/micro"
+	"github.com/manyakrus/starter/stopapp"
+
+	mail "github.com/xhit/go-simple-mail/v2"
+	//	"gopkg.in/gomail.v2"
+)
+
+// log - глобальный логгер приложения
+var log = logger.GetLog()
+
+// lastSendTime - время последней отправки сообщения и мьютекс
+var lastSendTime = lastSendTimeMutex{}
+
+// Conn - клиент соединения Email
+var Conn *mail.SMTPClient
+
+// MaxSendMessageCountIn1Second - максимальное количество сообщений в 1 секунду
+var MaxSendMessageCountIn1Second float32 = 33 //Валера сказал 33 оптимально было при испытании
+
+// lastSendTimeMutex - структура хранения времени последней отправки и мьютекс
+type lastSendTimeMutex struct {
+	time time.Time
+	sync.Mutex
+}
+
+// Settings хранит все нужные переменные окружения
+var Settings SettingsINI
+
+// SettingsINI - структура для хранения всех нужных переменных окружения
+type SettingsINI struct {
+	EMAIL_SMTP_SERVER    string
+	EMAIL_POP3_SERVER    string
+	EMAIL_SMTP_PORT      string
+	EMAIL_POP3_PORT      string
+	EMAIL_LOGIN          string
+	EMAIL_PASSWORD       string
+	EMAIL_SEND_TO_TEST   string
+	EMAIL_AUTHENTICATION string
+	EMAIL_ENCRYPTION     string
+}
+
+//type Attachment struct {
+//	Filename string
+//	File     []byte
+//}
+
+// SendMessage - отправка сообщения Email, без вложений
+func SendMessage(email_send_to string, text string, subject string) error {
+	var err error
+
+	MassAttachments := make([]mail.File, 0)
+	err = SendEmail(email_send_to, text, subject, MassAttachments)
+	return err
+}
+
+// SendEmail - отправка сообщения Email
+func SendEmail(email_send_to string, text string, subject string, MassAttachments []mail.File) error {
+	var err error
+
+	if email_send_to == "" {
+		text1 := "email_send_to is empty !"
+		log.Errorln(text1)
+		err = errors.New(text1)
+		return err
+	}
+
+	if text == "" {
+		text1 := "text is empty !"
+		log.Errorln(text1)
+		err = errors.New(text1)
+		return err
+	}
+
+	if Conn == nil {
+		err = Connect_err()
+		if err != nil {
+			log.Error("Connect_err() error: ", err)
+			return err
+		}
+	}
+
+	log.Debug("email_send_to: ", email_send_to, " text: ", text)
+
+	to := string(email_send_to)
+	msg := text
+
+	strFrom := Settings.EMAIL_LOGIN
+	MessageEmail := mail.NewMSG()
+	MessageEmail.SetFrom(strFrom)
+	//MessageEmail.SetSender(strFrom)
+	MessageEmail.SetSubject(subject)
+	MessageEmail.SetBody(mail.TextHTML, msg)
+
+	//емайлы кому, через запятую
+	MassTo := make([]string, 0)
+	MassTo = strings.Split(to, ",")
+	for _, v := range MassTo {
+		MessageEmail.AddTo(v)
+	}
+
+	//вложения
+	for _, v := range MassAttachments {
+		MessageEmail.Attach(&v)
+	}
+
+	//отправка
+	ctxMain := contextmain.GetContext()
+	ctx, cancel := context.WithTimeout(ctxMain, 60*time.Second)
+	defer cancel()
+
+	fn := func() error {
+		err = MessageEmail.Send(Conn)
+		//if err != nil {
+		//	err1 := fmt.Errorf("Send() error: %w", err)
+		//	return err1
+		//}
+		return err
+	}
+	err = micro.GoGo(ctx, fn)
+
+	return err
+}
+
+// Connect - подключение клиента Email
+func Connect() {
+	err := Connect_err()
+	if err != nil {
+		log.Panicln("Connect() error: ", err)
+	} else {
+		log.Info("Email connected: ", Settings.EMAIL_LOGIN)
+	}
+
+}
+
+// Connect_err - подключение клиента EMail
+func Connect_err() error {
+	var err error
+
+	if Settings.EMAIL_LOGIN == "" {
+		LoadEnv()
+	}
+
+	Encryption := FindEncryption_FromString(Settings.EMAIL_ENCRYPTION)
+	Authentication := FindAuthentication_FromString(Settings.EMAIL_AUTHENTICATION)
+
+	SMTPClient := mail.NewSMTPClient()
+	SMTPClient.Host = Settings.EMAIL_SMTP_SERVER
+	SMTPClient.Port, _ = strconv.Atoi(Settings.EMAIL_SMTP_PORT)
+	SMTPClient.Username = Settings.EMAIL_LOGIN
+	SMTPClient.Password = Settings.EMAIL_PASSWORD
+	SMTPClient.Encryption = Encryption
+	SMTPClient.Authentication = Authentication
+	SMTPClient.KeepAlive = true
+	SMTPClient.SendTimeout = 60 * time.Second
+	//Conn, err = SMTPClient.Connect()
+
+	fn := func() error {
+		Conn, err = SMTPClient.Connect()
+		if err != nil {
+			err1 := fmt.Errorf("Send() error: %w", err)
+			return err1
+		}
+		return err
+	}
+
+	ctxMain := contextmain.GetContext()
+	ctx, cancel := context.WithTimeout(ctxMain, 60*time.Second)
+	defer cancel()
+	err = micro.GoGo(ctx, fn)
+
+	return err
+}
+
+// CloseConnection_err - остановка работы клиента Email и возврат ошибки
+func CloseConnection_err() error {
+	var err error
+
+	if Conn == nil {
+		return err
+	}
+
+	err = Conn.Close()
+	if err != nil {
+		text1 := "smtp.Close() error: " + err.Error()
+		err1 := errors.New(text1)
+		log.Error(text1)
+		return err1
+	}
+
+	return err
+}
+
+// CloseConnection - остановка работы клиента Email
+func CloseConnection() {
+	err := CloseConnection_err()
+	if err != nil {
+		log.Panic("Email CloseConnection() error: ", err)
+	} else {
+		log.Info("Email connection closed")
+	}
+
+}
+
+// WaitStop - ожидает отмену глобального контекста или сигнала завершения приложения
+func WaitStop() {
+
+	select {
+	//case <-stopapp.SignalInterrupt:
+	//	log.Warn("Interrupt clean shutdown.")
+	//	contextmain.CancelContext()
+	case <-contextmain.GetContext().Done():
+		log.Warn("Context app is canceled.")
+	}
+
+	//
+	stopapp.WaitTotalMessagesSendingNow("email")
+
+	//
+	CloseConnection()
+	stopapp.GetWaitGroup_Main().Done()
+}
+
+// StartDB - делает соединение с БД, отключение и др.
+func Start() {
+	LoadEnv()
+	Connect()
+
+	stopapp.GetWaitGroup_Main().Add(1)
+	go WaitStop()
+
+}
+
+// LoadEnv - загружает переменные окружения в структуру из файла или из переменных окружения
+func LoadEnv() {
+
+	dir := micro.ProgramDir()
+	filename := dir + ".env"
+	LoadEnv_FromFile(filename)
+}
+
+// LoadEnv_FromFile загружает переменные окружения в структуру из файла или из переменных окружения
+func LoadEnv_FromFile(filename string) {
+	//var err error
+	//err := godotenv.Load(Filename_Settings)
+	//if err != nil {
+	//	log.Fatal("Error loading " + Filename_Settings + " file, error: " + err.Error())
+	//}
+
+	err := godotenv.Load(filename)
+	if err != nil {
+		log.Debug("Error parse .env file error: " + err.Error())
+	} else {
+		log.Info("load .env from file: ", filename)
+	}
+
+	Settings = SettingsINI{}
+	Settings.EMAIL_SMTP_SERVER = os.Getenv("EMAIL_SMTP_SERVER")
+	Settings.EMAIL_POP3_SERVER = os.Getenv("EMAIL_POP3_SERVER")
+	Settings.EMAIL_SMTP_PORT = os.Getenv("EMAIL_SMTP_PORT")
+	Settings.EMAIL_LOGIN = os.Getenv("EMAIL_LOGIN")
+	Settings.EMAIL_PASSWORD = os.Getenv("EMAIL_PASSWORD")
+	Settings.EMAIL_SEND_TO_TEST = os.Getenv("EMAIL_SEND_TO_TEST")
+	//Settings.EMAIL_SUBJECT = os.Getenv("EMAIL_SUBJECT")
+	Settings.EMAIL_AUTHENTICATION = os.Getenv("EMAIL_AUTHENTICATION")
+	Settings.EMAIL_ENCRYPTION = os.Getenv("EMAIL_ENCRYPTION")
+
+	if Settings.EMAIL_SMTP_SERVER == "" {
+		log.Warn("Need fill EMAIL_SMTP_SERVER ! in file ", filename)
+	}
+
+	if Settings.EMAIL_POP3_SERVER == "" {
+		log.Warn("Need fill EMAIL_POP3_SERVER ! in file ", filename)
+	}
+
+	if Settings.EMAIL_SMTP_PORT == "" {
+		log.Panicln("Need fill EMAIL_SMTP_PORT ! in file ", filename)
+	}
+
+	if Settings.EMAIL_LOGIN == "" {
+		log.Panicln("Need fill EMAIL_LOGIN ! in file ", filename)
+	}
+
+	if Settings.EMAIL_PASSWORD == "" {
+		log.Panicln("Need fill EMAIL_PASSWORD ! in file ", filename)
+	}
+
+	if Settings.EMAIL_SEND_TO_TEST == "" && micro.IsTestApp() == true {
+		log.Info("Need fill EMAIL_SEND_TO_TEST ! in file ", filename)
+	}
+
+	//if Settings.EMAIL_SUBJECT == "" {
+	//	log.Panicln("Need fill EMAIL_SUBJECT ! in file ", filename)
+	//}
+
+	if Settings.EMAIL_AUTHENTICATION == "" {
+		log.Warn("Need fill EMAIL_AUTHENTICATION ! in file ", filename)
+	}
+
+	if Settings.EMAIL_ENCRYPTION == "" {
+		log.Warn("Need fill EMAIL_ENCRYPTION ! in file ", filename)
+	}
+
+}
+
+// FindEncryption_FromString - находит Encryption из строки
+func FindEncryption_FromString(s string) mail.Encryption {
+	Otvet := mail.EncryptionNone
+
+	switch s {
+	case "EncryptionSSL":
+		Otvet = mail.EncryptionSSL
+	case "EncryptionSSLTLS":
+		Otvet = mail.EncryptionSSLTLS
+	case "EncryptionSTARTTLS":
+		Otvet = mail.EncryptionSTARTTLS
+	case "EncryptionTLS":
+		Otvet = mail.EncryptionTLS
+	}
+
+	return Otvet
+}
+
+// FindAuthentication_FromString - находит AuthType из строки
+func FindAuthentication_FromString(s string) mail.AuthType {
+	Otvet := mail.AuthNone
+
+	switch s {
+	case "AuthLogin":
+		Otvet = mail.AuthLogin
+	case "AuthPlain":
+		Otvet = mail.AuthPlain
+	case "AuthCRAMMD5":
+		Otvet = mail.AuthCRAMMD5
+	}
+
+	return Otvet
+}
--- a/email/email_test.go
+++ b/email/email_test.go
@@ -0,0 +1,47 @@
+package email
+
+import (
+	mail "github.com/xhit/go-simple-mail/v2"
+	"github.com/manyakrus/starter/config"
+	"testing"
+)
+
+func TestSendMessage(t *testing.T) {
+	config.LoadEnv()
+	Connect()
+	EMAIL_SEND_TO_TEST := Settings.EMAIL_SEND_TO_TEST
+	text := "TEST ТЕСТ utf8 русский язык"
+
+	err := SendMessage(EMAIL_SEND_TO_TEST, text, "Test")
+	if err != nil {
+		log.Info("email_test.TestSendMessage() error: ", err)
+	}
+
+	CloseConnection()
+}
+
+func TestSendEmail(t *testing.T) {
+	config.LoadEnv()
+	Connect()
+	EMAIL_SEND_TO_TEST := Settings.EMAIL_SEND_TO_TEST
+	//EMAIL_SEND_TO_TEST = EMAIL_SEND_TO_TEST + ",noreply@note.atomsbt.ru"
+	//EMAIL_SEND_TO_TEST = "z2007@list.ru"
+	text := "TEST ТЕСТ utf8 русский язык"
+	Attachment1 := mail.File{}
+	Attachment1.Name = "test.txt"
+	Attachment1.Data = []byte(text)
+	MassAttachment := make([]mail.File, 0)
+	MassAttachment = append(MassAttachment, Attachment1)
+
+	err := SendEmail(EMAIL_SEND_TO_TEST, text, "Test", MassAttachment)
+	if err != nil {
+		log.Info("email_test.TestSendEmail() error: ", err)
+	}
+
+	CloseConnection()
+}
+
+func TestConnect(t *testing.T) {
+	Connect()
+	CloseConnection()
+}
--- a/email_imap/email_imap.go
+++ b/email_imap/email_imap.go
@@ -0,0 +1,569 @@
+package email_imap
+
+import (
+	//"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"github.com/emersion/go-imap"
+	imapModule "github.com/emersion/go-imap/client"
+	"github.com/emersion/go-message"
+	mail "github.com/emersion/go-message/mail"
+	"github.com/joho/godotenv"
+	simplemail "github.com/xhit/go-simple-mail/v2"
+	"github.com/manyakrus/starter/contextmain"
+	"github.com/manyakrus/starter/email"
+	"github.com/manyakrus/starter/log"
+	"github.com/manyakrus/starter/micro"
+	"github.com/manyakrus/starter/stopapp"
+	"io"
+	"io/ioutil"
+	"os"
+	"strings"
+	"time"
+)
+
+var Conn *imapModule.Client
+var MailInbox *imap.MailboxStatus // папка inbox
+
+// Settings хранит все нужные переменные окружения
+var Settings SettingsINI
+
+var FOLDER_NAME_INBOX = `INBOX`
+var ErrEmptyInbox = fmt.Errorf("empty inbox")
+
+// SettingsINI - структура для хранения всех нужных переменных окружения
+type SettingsINI struct {
+	EMAIL_IMAP_SERVER  string
+	EMAIL_IMAP_PORT    string
+	EMAIL_LOGIN        string
+	EMAIL_PASSWORD     string
+	EMAIL_SEND_TO_TEST string
+	//EMAIL_SUBJECT        string
+	EMAIL_AUTHENTICATION string
+	EMAIL_ENCRYPTION     string
+}
+
+type Attachment struct {
+	Filename string
+	Data     []byte
+}
+
+// Connect - подключение клиента Email
+func Connect() {
+	err := Connect_err()
+	if err != nil {
+		log.Panicln("Connect() error: ", err)
+	} else {
+		log.Info("Email connected: ", Settings.EMAIL_LOGIN)
+	}
+
+}
+
+// Connect_err - Однократно Устанавливает соединение по требованию
+func Connect_err() error {
+	var err error
+
+	if Settings.EMAIL_LOGIN == "" {
+		LoadEnv()
+	}
+
+	strFrom := Settings.EMAIL_LOGIN
+	strPass := Settings.EMAIL_PASSWORD
+	strHost := Settings.EMAIL_IMAP_SERVER
+
+	//log.Debugf("Connecting to server %s", strHost)
+
+	//подключение к серверу
+	fn := func() error {
+		Conn, err = imapModule.Dial(strHost + ":" + Settings.EMAIL_IMAP_PORT)
+		if err != nil {
+			err1 := fmt.Errorf("Send() error: %w", err)
+			return err1
+		}
+		return err
+	}
+
+	ctxMain := contextmain.GetContext()
+	ctx, cancel := context.WithTimeout(ctxMain, 60*time.Second)
+	defer cancel()
+	err = micro.GoGo(ctx, fn)
+
+	//Conn, err := imapModule.Dial(strHost + ":" + strconv.Itoa(Settings.EMAIL_SMTP_PORT))
+	if err != nil {
+		return err
+	}
+
+	// Login
+	fn = func() error {
+		err = Conn.Login(strFrom, strPass)
+		if err != nil {
+			err1 := fmt.Errorf("Send() error: %w", err)
+			return err1
+		}
+		return err
+	}
+
+	ctx, cancel2 := context.WithTimeout(ctxMain, 60*time.Second)
+	defer cancel2()
+	err = micro.GoGo(ctx, fn)
+
+	//err = Conn.Login(strFrom, strPass)
+	if err != nil {
+		return err
+	}
+	log.Infof("Logged in %s", strFrom)
+
+	MailInbox = SelectInbox()
+
+	return nil
+}
+
+// SelectInbox - возвращает емайл папку Inbox
+func SelectInbox() *imap.MailboxStatus {
+	var MailInbox *imap.MailboxStatus
+	MailInbox = SelectFolder(FOLDER_NAME_INBOX)
+
+	return MailInbox
+}
+
+// SelectInbox - возвращает емайл папку Inbox
+func SelectFolder(FolderName string) *imap.MailboxStatus {
+	var MailInbox *imap.MailboxStatus
+
+	if Conn == nil {
+		log.Errorf("mailconn.SelectFolder() error conn = nil")
+		return MailInbox
+	}
+
+	// Select INBOX
+	var err error
+
+	fn := func() error {
+		MailInbox, err = Conn.Select(FolderName, false)
+		if err != nil {
+			err1 := fmt.Errorf("Send() error: %w", err)
+			return err1
+		}
+		return err
+	}
+
+	ctxMain := contextmain.GetContext()
+	ctx, cancel := context.WithTimeout(ctxMain, 60*time.Second)
+	defer cancel()
+	err = micro.GoGo(ctx, fn)
+
+	//MailInbox, err = Conn.Select(FolderName, false)
+	if err != nil {
+		log.Error("mailconn.SelectFolder() Select(", FolderName, ") error: %s", err)
+		panic(err)
+	}
+	if MailInbox == nil {
+		log.Error("mailconn.SelectFolder() Select(", FolderName, ") MailInbox=nil, error: %s", err)
+		panic(err)
+	}
+
+	return MailInbox
+}
+
+// ReplaceMessage -- перемещает сообщение в другую папку
+func ReplaceMessage(msg *imap.Message, FolderName string) error {
+	if msg == nil {
+		return fmt.Errorf("ReplaceMessage(): msg==nil")
+	}
+
+	SeqSet := FindSeqSet(msg.Uid)
+
+	var err error
+	//ctxMain := contextmain.GetContext()
+	//Ctx1, CancelFunc1 := context.WithTimeout(ctxMain, time.Second*30)
+	//defer CancelFunc1()
+
+	err = Conn.UidMove(SeqSet, FolderName)
+
+	//select {
+	//case <-Ctx1.Done():
+	//	Text1 := "mailconn.MsgNext() Fetch() error: TimeOut"
+	//	err = errors.New(Text1)
+	//	return err
+	//case err = <-Chan1:
+	//}
+	////err := mc.conn.UidMove(SeqSet, FolderName)
+
+	return err
+}
+
+// FindSeqSet -- находит SeqSet по номеру сообщения
+func FindSeqSet(Id uint32) *imap.SeqSet {
+
+	SeqSet := new(imap.SeqSet)
+	SeqSet.AddNum(Id)
+
+	return SeqSet
+}
+
+// FindFolderName - возвращает имя папки imap
+func FindFolderName(MainFolderName, SubFolderName string) string {
+	Otvet := MainFolderName
+
+	if SubFolderName != "" {
+		Otvet = MainFolderName + `/` + SubFolderName
+	}
+
+	return Otvet
+}
+
+// ForwardMessage -- перенаправляет емайл
+func ForwardMessage(msg *imap.Message, email_send_to string) error {
+	//BodyText := msg.Body
+	//BodyText = "Обращение поступило от: " + msg.Envelope.From.MailboxName + "\n\r<BR>" +
+	//	"----------------------------------------------------------\n\r<BR><BR>" +
+	//	BodyText
+
+	var err error
+	//ctxMain := contextmain.GetContext()
+	//Ctx1, CancelFunc1 := context.WithTimeout(ctxMain, time.Second*30)
+	//defer CancelFunc1()
+
+	Body, Attachments, err := ReadBody(msg)
+
+	MassAttachments := make([]simplemail.File, 0)
+	for _, v := range Attachments {
+		Attachment1 := simplemail.File{}
+		Attachment1.Name = v.Filename
+		Attachment1.Data = v.Data
+		MassAttachments = append(MassAttachments, Attachment1)
+	}
+
+	err = email.SendEmail(email_send_to, Body, msg.Envelope.Subject, MassAttachments)
+
+	//select {
+	//case <-Ctx1.Done():
+	//	Text1 := "mailconn.MsgNext() Fetch() error: TimeOut"
+	//	err = errors.New(Text1)
+	//	return err
+	//case err = <-Chan1:
+	//}
+
+	return err
+}
+
+// WaitStop - ожидает отмену глобального контекста или сигнала завершения приложения
+func WaitStop() {
+
+	select {
+	//case <-stopapp.SignalInterrupt:
+	//	log.Warn("Interrupt clean shutdown.")
+	//	contextmain.CancelContext()
+	case <-contextmain.GetContext().Done():
+		log.Warn("Context app is canceled.")
+	}
+
+	//
+	stopapp.WaitTotalMessagesSendingNow("email")
+
+	//
+	CloseConnection()
+	stopapp.GetWaitGroup_Main().Done()
+}
+
+// StartDB - делает соединение с БД, отключение и др.
+func Start() {
+	LoadEnv()
+	Connect_err()
+
+	stopapp.GetWaitGroup_Main().Add(1)
+	go WaitStop()
+
+}
+
+// LoadEnv - загружает переменные окружения в структуру из файла или из переменных окружения
+func LoadEnv() {
+
+	dir := micro.ProgramDir()
+	filename := dir + ".env"
+	LoadEnv_FromFile(filename)
+}
+
+// LoadEnv_FromFile загружает переменные окружения в структуру из файла или из переменных окружения
+func LoadEnv_FromFile(filename string) {
+	//var err error
+	//err := godotenv.Load(Filename_Settings)
+	//if err != nil {
+	//	log.Fatal("Error loading " + Filename_Settings + " file, error: " + err.Error())
+	//}
+
+	err := godotenv.Load(filename)
+	if err != nil {
+		log.Debug("Error parse .env file error: " + err.Error())
+	} else {
+		log.Info("load .env from file: ", filename)
+	}
+
+	Settings = SettingsINI{}
+	Settings.EMAIL_IMAP_SERVER = os.Getenv("EMAIL_IMAP_SERVER")
+	Settings.EMAIL_IMAP_PORT = os.Getenv("EMAIL_IMAP_PORT")
+	Settings.EMAIL_LOGIN = os.Getenv("EMAIL_LOGIN")
+	Settings.EMAIL_PASSWORD = os.Getenv("EMAIL_PASSWORD")
+	Settings.EMAIL_SEND_TO_TEST = os.Getenv("EMAIL_SEND_TO_TEST")
+	//Settings.EMAIL_SUBJECT = os.Getenv("EMAIL_SUBJECT")
+	Settings.EMAIL_AUTHENTICATION = os.Getenv("EMAIL_AUTHENTICATION")
+	Settings.EMAIL_ENCRYPTION = os.Getenv("EMAIL_ENCRYPTION")
+
+	if Settings.EMAIL_IMAP_SERVER == "" {
+		log.Panicln("Need fill EMAIL_SMTP_SERVER ! in file ", filename)
+	}
+
+	if Settings.EMAIL_IMAP_PORT == "" {
+		log.Panicln("Need fill EMAIL_SMTP_PORT ! in file ", filename)
+	}
+
+	if Settings.EMAIL_LOGIN == "" {
+		log.Panicln("Need fill EMAIL_LOGIN ! in file ", filename)
+	}
+
+	if Settings.EMAIL_PASSWORD == "" {
+		log.Panicln("Need fill EMAIL_PASSWORD ! in file ", filename)
+	}
+
+	if Settings.EMAIL_SEND_TO_TEST == "" && micro.IsTestApp() == true {
+		log.Info("Need fill EMAIL_SEND_TO_TEST ! in file ", filename)
+	}
+
+	//if Settings.EMAIL_SUBJECT == "" {
+	//	log.Panicln("Need fill EMAIL_SUBJECT ! in file ", filename)
+	//}
+
+	if Settings.EMAIL_AUTHENTICATION == "" {
+		log.Warn("Need fill EMAIL_AUTHENTICATION ! in file ", filename)
+	}
+
+	if Settings.EMAIL_ENCRYPTION == "" {
+		log.Warn("Need fill EMAIL_ENCRYPTION ! in file ", filename)
+	}
+
+}
+
+// CloseConnection - остановка работы клиента Email
+func CloseConnection() {
+	err := CloseConnection_err()
+	if err != nil {
+		log.Panic("Email imap CloseConnection() error: ", err)
+	} else {
+		log.Info("Email imap connection closed")
+	}
+
+}
+
+// CloseConnection_err -- закрывает соединение с почтовым сервером
+func CloseConnection_err() error {
+	var err error
+
+	fn := func() error {
+		err := Conn.Logout()
+		if err != nil {
+			err1 := fmt.Errorf("Send() error: %w", err)
+			return err1
+		}
+		return err
+	}
+
+	ctxMain := contextmain.GetContext()
+	ctx, cancel := context.WithTimeout(ctxMain, 60*time.Second)
+	defer cancel()
+	err = micro.GoGo(ctx, fn)
+
+	//err := Conn.Logout()
+	if err != nil {
+		log.Printf("MailConn.Logout(): err=\t%v", err)
+	}
+
+	Conn = nil
+
+	return err
+}
+
+// Stat - возвращает количество сообщений и ИД первого непрочитанного
+func Stat() (count, id int) {
+	// Select INBOX
+	MailInbox := SelectInbox()
+	count = int(MailInbox.Messages)
+	id = int(MailInbox.UnseenSeqNum)
+
+	return count, id
+}
+
+// Безопасно читает тело сообщения
+func ReadBody(Msg *imap.Message) (BodyText string, Attachments []Attachment, err error) {
+
+	Attachments = make([]Attachment, 0)
+
+	chErr := make(chan string, 2)
+	if Msg == nil {
+		//chErr <- "MsgEmail.readBody().fnRead(): сообщение не присвоена в структуре"
+		sError := "MsgEmail.readBody(): Msg == nil"
+		err = fmt.Errorf(sError)
+		chErr <- sError
+		return
+	}
+	var section imap.BodySectionName
+	l := Msg.GetBody(&section)
+	if l == nil {
+		sError := "MsgEmail.readBody(): GetBody() = nil"
+		err = fmt.Errorf(sError)
+		chErr <- sError
+		return
+		//log.Fatal("Server didn't returned message body")
+	}
+
+	//sBody := l.(*bytes.Buffer).String()
+
+	// Create a new mail reader
+	mr, err := mail.CreateReader(l)
+	if err != nil {
+		sError := fmt.Sprintf("MsgEmail.readBody(): CreateReader() error: %v", err)
+		err = fmt.Errorf(sError)
+		chErr <- sError
+		return
+		//log.Fatal(err)
+	}
+
+	//buf := make([]byte, 0)
+	//n, err := mr.Read(buf)
+
+	// Process each message's part
+	//sBody := ""
+	BodyText = ""
+	for {
+		p, err := mr.NextPart()
+		if err == io.EOF {
+			break
+		}
+		if message.IsUnknownCharset(err) {
+			continue
+		}
+		if err != nil {
+			sError := fmt.Sprintf("MsgEmail.readBody(): NextPart() error: %v", err)
+			err = fmt.Errorf(sError)
+			chErr <- sError
+			if strings.Contains(err.Error(), "EOF") {
+				break
+			}
+		}
+
+		if p == nil {
+			continue
+		}
+
+		switch p.Header.(type) {
+		case *mail.InlineHeader:
+			// This is the message's text (can be plain-text or HTML)
+			b, err := ioutil.ReadAll(p.Body)
+			if err != nil {
+				sError := fmt.Sprintf("MsgEmail.readBody(): ReadAll() error: %v", err)
+				err = fmt.Errorf(sError)
+				chErr <- sError
+			}
+			//sBody = sBody + string(b)
+			BodyText = string(b)
+			break
+
+		case *mail.AttachmentHeader:
+			h := p.Header.(*mail.AttachmentHeader)
+			// This is an attachment
+			filename, _ := h.Filename()
+			//log.Println("Got attachment: %v", filename)
+			var Data []byte
+			Data, err := ioutil.ReadAll(p.Body)
+			if err != nil {
+				sError := fmt.Sprintf("MsgEmail.readBody(): ReadAll() error: %v", err)
+				err = fmt.Errorf(sError)
+				chErr <- sError
+			}
+
+			if filename != "" {
+				Attachment1 := Attachment{}
+				Attachment1.Filename = filename
+				Attachment1.Data = Data
+				Attachments = append(Attachments, Attachment1)
+			}
+
+		}
+	}
+
+	//sf.StrBody_ = sBody
+
+	//body_, err := io.ReadAll(sf.Msg.GetBody(&section))
+	//if err != nil {
+	//	chErr <- fmt.Sprintf("MsgEmail.readBody().fnRead(): при чтении тела письма, err=\t%v", err)
+	//}
+	//sf.StrBody_ = html.UnescapeString(string(body_))
+	//if err = sf.getEmail(); err != nil {
+	//	chErr <- fmt.Sprintf("MsgEmail.readBody().fnRead(): при получении адресата письма, err=\t%v", err)
+	//}
+
+	return
+}
+
+// Безопасно получает тему сообщения
+func ReadHeader(msg *imap.Message) mail.Header {
+	var Header mail.Header
+
+	// Get the whole message body
+	var section imap.BodySectionName
+	section = imap.BodySectionName{}
+	//items := []imap.FetchItem{section.FetchItem()}
+
+	r := msg.GetBody(&section)
+	if r == nil {
+		log.Fatal("Server didn't returned message body")
+	}
+
+	// Create a new mail reader
+	mr, err := mail.CreateReader(r)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	Header = mr.Header
+
+	return Header
+}
+
+// ReadMessage -- возвращает пиьмо с сервера, с номером по порядку=id
+func ReadMessage(id int) (*imap.Message, error) {
+	var err error
+	Otvet := &imap.Message{}
+
+	messages := make(chan *imap.Message, 1)
+	nextNum := uint32(id)
+	seqset := new(imap.SeqSet)
+	seqset.AddNum(nextNum)
+	var section imap.BodySectionName
+	items := []imap.FetchItem{imap.FetchBody, imap.FetchUid, imap.FetchEnvelope, imap.FetchBodyStructure, section.FetchItem()}
+	err = Conn.Fetch(seqset, items, messages)
+	if err != nil {
+		return Otvet, err
+	}
+
+	TimeOutSeconds := 60
+	duration := time.Duration(TimeOutSeconds) * time.Second
+	Ctx1, CancelFunc1 := context.WithTimeout(contextmain.GetContext(), duration)
+	defer CancelFunc1()
+	select {
+	case <-Ctx1.Done():
+		Text1 := fmt.Sprint("mailconn.MsgNext() Fetch() error: TimeOut ", TimeOutSeconds, " seconds")
+		err = errors.New(Text1)
+		return Otvet, err
+	case Otvet = <-messages:
+	}
+
+	if Otvet == nil {
+		text1 := fmt.Sprint("mailconn.MsgNext() No email with id: ", nextNum)
+		err := errors.New(text1)
+		//chRes_ <- text1
+		return Otvet, err
+	}
+
+	return Otvet, err
+}
--- a/email_imap/email_imap_test.go
+++ b/email_imap/email_imap_test.go
@@ -0,0 +1,46 @@
+package email_imap
+
+import (
+	"testing"
+)
+
+func TestConnect(t *testing.T) {
+	Connect()
+	defer CloseConnection()
+}
+
+func TestSelectInbox(t *testing.T) {
+	Connect()
+	defer CloseConnection()
+
+	SelectInbox()
+}
+
+func TestReplaceMessage(t *testing.T) {
+	//Connect()
+	//defer CloseConnection()
+	//
+	//SelectInbox()
+	//ReplaceMessage(msg, FOLDER_NAME_INBOX)
+}
+
+func TestReadMessage(t *testing.T) {
+	Connect()
+	defer CloseConnection()
+
+	SelectInbox()
+	//SelectFolder("Архив")
+	size, _ := Stat()
+	if size <= 0 {
+		t.Log("size: 0")
+		return
+	}
+
+	msg, err := ReadMessage(size)
+	if err != nil {
+		t.Error("emal_imap_test.TestReadMessage() error: ", err)
+	} else {
+		t.Log("message: ", msg)
+	}
+
+}
--- a/go.mod
+++ b/go.mod
@@ -3,9 +3,11 @@ module github.com/manyakrus/starter
 go 1.18

 require (
-	github.com/ManyakRus/logrus v0.0.0-20230425135901-49786dc30ad1
+	github.com/ManyakRus/logrus v0.0.0-20230426064230-515895169d22
 	github.com/camunda/zeebe/clients/go/v8 v8.1.8
 	github.com/denisenkom/go-mssqldb v0.12.3
+	github.com/emersion/go-imap v1.2.1
+	github.com/emersion/go-message v0.16.0
 	github.com/gofiber/fiber/v2 v2.42.0
 	github.com/golang-module/carbon/v2 v2.2.3
 	github.com/jackc/pgx/v4 v4.17.2
@@ -15,10 +17,11 @@ require (
 	github.com/mattn/go-sqlite3 v1.14.16
 	github.com/mdp/qrterminal/v3 v3.0.0
 	github.com/nats-io/nats.go v1.16.0
-	github.com/sashabaranov/go-gpt3 v1.3.1
+	github.com/sashabaranov/go-openai v1.9.1
 	github.com/segmentio/kafka-go v0.4.39
+	github.com/xhit/go-simple-mail/v2 v2.13.0
 	gitlab.aescorp.ru/dsp_dev/claim/common/object_model v0.0.108
-	go.mau.fi/whatsmeow v0.0.0-20230226124255-e5c8f3c95d78
+	go.mau.fi/whatsmeow v0.0.0-20230427180258-7f679583b39b
 	golang.org/x/exp v0.0.0-20230418202329-0354be287a23
 	gorm.io/driver/postgres v1.4.8
 	gorm.io/driver/sqlserver v1.4.2
@@ -30,7 +33,10 @@ require (
 	github.com/andybalholm/brotli v1.0.4 // indirect
 	github.com/asaskevich/govalidator v0.0.0-20200108200545-475eaeb16496 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/emersion/go-sasl v0.0.0-20200509203442-7bfe0ed36a21 // indirect
+	github.com/emersion/go-textwrapper v0.0.0-20200911093747-65d896831594 // indirect
 	github.com/go-ozzo/ozzo-validation/v4 v4.3.0 // indirect
+	github.com/go-test/deep v1.1.0 // indirect
 	github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 // indirect
 	github.com/golang-sql/sqlexp v0.1.0 // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
@@ -65,21 +71,22 @@ require (
 	github.com/savsgio/gotils v0.0.0-20220530130905-52f3993e8d6d // indirect
 	github.com/stretchr/testify v1.8.1 // indirect
 	github.com/tinylib/msgp v1.1.6 // indirect
+	github.com/toorop/go-dkim v0.0.0-20201103131630-e1cd1a0a5208 // indirect
 	github.com/valyala/bytebufferpool v1.0.0 // indirect
 	github.com/valyala/fasthttp v1.44.0 // indirect
 	github.com/valyala/tcplisten v1.0.0 // indirect
 	github.com/vmihailenco/msgpack/v5 v5.3.5 // indirect
 	github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect
 	go.mau.fi/libsignal v0.1.0 // indirect
-	golang.org/x/crypto v0.6.0 // indirect
-	golang.org/x/net v0.6.0 // indirect
+	golang.org/x/crypto v0.8.0 // indirect
+	golang.org/x/net v0.9.0 // indirect
 	golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8 // indirect
-	golang.org/x/sys v0.5.0 // indirect
-	golang.org/x/text v0.7.0 // indirect
+	golang.org/x/sys v0.7.0 // indirect
+	golang.org/x/text v0.9.0 // indirect
 	google.golang.org/appengine v1.6.7 // indirect
 	google.golang.org/genproto v0.0.0-20220624142145-8cd45d7dbd1f // indirect
 	google.golang.org/grpc v1.49.0 // indirect
-	google.golang.org/protobuf v1.28.1 // indirect
+	google.golang.org/protobuf v1.30.0 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	rsc.io/qr v0.2.0 // indirect
--- a/go.sum
+++ b/go.sum
@@ -43,8 +43,8 @@ github.com/Azure/azure-sdk-for-go/sdk/internal v1.0.0/go.mod h1:eWRD7oawr1Mu1sLC
 github.com/AzureAD/microsoft-authentication-library-for-go v0.5.1/go.mod h1:Vt9sXTKwMyGcOxSmLDMnGPgqsUg7m8pe215qMLrDXw4=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
-github.com/ManyakRus/logrus v0.0.0-20230425135901-49786dc30ad1 h1:DHDHcELzYHjddChELUD//dbGrhSIJcRVOMU2HsQOSOg=
-github.com/ManyakRus/logrus v0.0.0-20230425135901-49786dc30ad1/go.mod h1:KbfWJjL1T+JHs/0tdcuqW6CKUakBEQ7oG9u5xpEfbTE=
+github.com/ManyakRus/logrus v0.0.0-20230426064230-515895169d22 h1:DrHNlqXfwvCpCqn4MfRn4NBtezqWL5GLor3jC7QFPj0=
+github.com/ManyakRus/logrus v0.0.0-20230426064230-515895169d22/go.mod h1:KbfWJjL1T+JHs/0tdcuqW6CKUakBEQ7oG9u5xpEfbTE=
 github.com/Masterminds/semver/v3 v3.1.1/go.mod h1:VPu/7SZ7ePZ3QOrcuXROw5FAcLl4a0cBrbBpGY/8hQs=
 github.com/andybalholm/brotli v1.0.4 h1:V7DdXeJtZscaqfNuAdSRuRFzuiKlHSC/Zh3zl9qY3JY=
 github.com/andybalholm/brotli v1.0.4/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
@@ -78,6 +78,15 @@ github.com/denisenkom/go-mssqldb v0.12.3 h1:pBSGx9Tq67pBOTLmxNuirNTeB8Vjmf886Kx+
 github.com/denisenkom/go-mssqldb v0.12.3/go.mod h1:k0mtMFOnU+AihqFxPMiF05rtiDrorD1Vrm1KEz5hxDo=
 github.com/dnaeon/go-vcr v1.1.0/go.mod h1:M7tiix8f0r6mKKJ3Yq/kqU1OYf3MnfmBWVbPx/yU9ko=
 github.com/dnaeon/go-vcr v1.2.0/go.mod h1:R4UdLID7HZT3taECzJs4YgbbH6PIGXB6W/sc5OLb6RQ=
+github.com/emersion/go-imap v1.2.1 h1:+s9ZjMEjOB8NzZMVTM3cCenz2JrQIGGo5j1df19WjTA=
+github.com/emersion/go-imap v1.2.1/go.mod h1:Qlx1FSx2FTxjnjWpIlVNEuX+ylerZQNFE5NsmKFSejY=
+github.com/emersion/go-message v0.15.0/go.mod h1:wQUEfE+38+7EW8p8aZ96ptg6bAb1iwdgej19uXASlE4=
+github.com/emersion/go-message v0.16.0 h1:uZLz8ClLv3V5fSFF/fFdW9jXjrZkXIpE1Fn8fKx7pO4=
+github.com/emersion/go-message v0.16.0/go.mod h1:pDJDgf/xeUIF+eicT6B/hPX/ZbEorKkUMPOxrPVG2eQ=
+github.com/emersion/go-sasl v0.0.0-20200509203442-7bfe0ed36a21 h1:OJyUGMJTzHTd1XQp98QTaHernxMYzRaOasRir9hUlFQ=
+github.com/emersion/go-sasl v0.0.0-20200509203442-7bfe0ed36a21/go.mod h1:iL2twTeMvZnrg54ZoPDNfJaJaqy0xIQFuBdrLsmspwQ=
+github.com/emersion/go-textwrapper v0.0.0-20200911093747-65d896831594 h1:IbFBtwoTQyw0fIM5xv1HF+Y+3ZijDR839WMulgxCcUY=
+github.com/emersion/go-textwrapper v0.0.0-20200911093747-65d896831594/go.mod h1:aqO8z8wPrjkscevZJFVE1wXJrLpC5LtJG7fqLOsPb2U=
 github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
@@ -95,6 +104,8 @@ github.com/go-ozzo/ozzo-validation/v4 v4.3.0/go.mod h1:2NKgrcHl3z6cJs+3Oo940FPRi
 github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfCHuOE=
 github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/go-test/deep v1.1.0 h1:WOcxcdHcvdgThNXjw0t76K42FXTU7HpNQWHpA2HHNlg=
+github.com/go-test/deep v1.1.0/go.mod h1:5C2ZWiW0ErCdrYzpqxLbTX7MG14M9iiw8DgHncVwcsE=
 github.com/gofiber/fiber/v2 v2.42.0 h1:Fnp7ybWvS+sjNQsFvkhf4G8OhXswvB6Vee8hM/LyS+8=
 github.com/gofiber/fiber/v2 v2.42.0/go.mod h1:3+SGNjqMh5VQH5Vz2Wdi43zTIV16ktlFd3x3R6O1Zlc=
 github.com/gofrs/uuid v4.0.0+incompatible h1:1SD/1F5pU8p29ybwgQSwpQk+mwdRrXCYuPhW6m+TnJw=
@@ -323,8 +334,8 @@ github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTE
 github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ=
 github.com/rs/zerolog v1.13.0/go.mod h1:YbFCdg8HfsridGWAh22vktObvhZbQsZXe4/zB0OKkWU=
 github.com/rs/zerolog v1.15.0/go.mod h1:xYTKnLHcpfU2225ny5qZjxnj9NvkumZYjJHlAThCjNc=
-github.com/sashabaranov/go-gpt3 v1.3.1 h1:ACQOAVX5CAV5rHt0oJOBMKo9BNcqVnmxEdjVxcjVAzw=
-github.com/sashabaranov/go-gpt3 v1.3.1/go.mod h1:BIZdbwdzxZbCrcKGMGH6u2eyGe1xFuX9Anmh3tCP8lQ=
+github.com/sashabaranov/go-openai v1.9.1 h1:3N52HkJKo9Zlo/oe1AVv5ZkCOny0ra58/ACvAxkN3MM=
+github.com/sashabaranov/go-openai v1.9.1/go.mod h1:lj5b/K+zjTSFxVLijLSTDZuP7adOgerWeFyZLUhAKRg=
 github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
 github.com/savsgio/dictpool v0.0.0-20221023140959-7bf2e61cea94 h1:rmMl4fXJhKMNWl+K+r/fq4FbbKI+Ia2m9hYBLm2h4G4=
 github.com/savsgio/dictpool v0.0.0-20221023140959-7bf2e61cea94/go.mod h1:90zrgN3D/WJsDd1iXHT96alCoN2KJo6/4x1DZC3wZs8=
@@ -355,6 +366,8 @@ github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKs
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/tinylib/msgp v1.1.6 h1:i+SbKraHhnrf9M5MYmvQhFnbLhAXSDWF8WWsuyRdocw=
 github.com/tinylib/msgp v1.1.6/go.mod h1:75BAfg2hauQhs3qedfdDZmWAPcFMAvJE5b9rGOMufyw=
+github.com/toorop/go-dkim v0.0.0-20201103131630-e1cd1a0a5208 h1:PM5hJF7HVfNWmCjMdEfbuOBNXSVF2cMFGgQTPdKCbwM=
+github.com/toorop/go-dkim v0.0.0-20201103131630-e1cd1a0a5208/go.mod h1:BzWtXXrXzZUvMacR0oF/fbDDgUPO8L36tDMmRAf14ns=
 github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
 github.com/valyala/fasthttp v1.44.0 h1:R+gLUhldIsfg1HokMuQjdQ5bh9nuXHPIfvkYUu9eR5Q=
@@ -369,6 +382,8 @@ github.com/xdg/scram v1.0.5 h1:TuS0RFmt5Is5qm9Tm2SoD89OPqe4IRiFtyFY4iwWXsw=
 github.com/xdg/scram v1.0.5/go.mod h1:lB8K/P019DLNhemzwFU4jHLhdvlE6uDZjXFejJXr49I=
 github.com/xdg/stringprep v1.0.3 h1:cmL5Enob4W83ti/ZHuZLuKD/xqJfus4fVPwE+/BDm+4=
 github.com/xdg/stringprep v1.0.3/go.mod h1:Jhud4/sHMO4oL310DaZAKk9ZaJ08SJfe+sJh0HrGL1Y=
+github.com/xhit/go-simple-mail/v2 v2.13.0 h1:OANWU9jHZrVfBkNkvLf8Ww0fexwpQVF/v/5f96fFTLI=
+github.com/xhit/go-simple-mail/v2 v2.13.0/go.mod h1:b7P5ygho6SYE+VIqpxA6QkYfv4teeyG4MKqB3utRu98=
 github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
@@ -379,8 +394,8 @@ gitlab.aescorp.ru/dsp_dev/claim/common/object_model v0.0.108 h1:ZtBQuNckYPeoheh0
 gitlab.aescorp.ru/dsp_dev/claim/common/object_model v0.0.108/go.mod h1:GipQ/BQkeb4EgKMMXyZtfnydEqSooOxQCxCqhbnp5/k=
 go.mau.fi/libsignal v0.1.0 h1:vAKI/nJ5tMhdzke4cTK1fb0idJzz1JuEIpmjprueC+c=
 go.mau.fi/libsignal v0.1.0/go.mod h1:R8ovrTezxtUNzCQE5PH30StOQWWeBskBsWE55vMfY9I=
-go.mau.fi/whatsmeow v0.0.0-20230226124255-e5c8f3c95d78 h1:HXq3VXJhSL/S6kZkrCYMUhCELinVrfpPhDFpklZvHnA=
-go.mau.fi/whatsmeow v0.0.0-20230226124255-e5c8f3c95d78/go.mod h1:zoTtv1CupGEyTew7TOwnBmTbHB4pVad2OzjTf5CVwa0=
+go.mau.fi/whatsmeow v0.0.0-20230427180258-7f679583b39b h1:VSSc37LfKMt7HYeu9NibbSRwELFN5wc/hreGyY+z+o4=
+go.mau.fi/whatsmeow v0.0.0-20230427180258-7f679583b39b/go.mod h1:+ObGpFE6cbbY4hKc1FmQH9MVfqaemmlXGXSnwDvCOyE=
 go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
 go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
 go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
@@ -417,8 +432,9 @@ golang.org/x/crypto v0.0.0-20220511200225-c6db032c6c88/go.mod h1:IxCIyHEi3zRg3s0
 golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/crypto v0.0.0-20221005025214-4161e89ecf1b/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/crypto v0.6.0 h1:qfktjS5LUO+fFKeJXZ+ikTRijMmljikvG68fpMMruSc=
 golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58=
+golang.org/x/crypto v0.8.0 h1:pd9TJtTueMTVQXzk8E2XESSMQDj/U7OUu0PqJqPXQjQ=
+golang.org/x/crypto v0.8.0/go.mod h1:mRqEX+O9/h5TFCrQhkgjo2yKi0yYA+9ecGkdQoHrywE=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
@@ -489,8 +505,9 @@ golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su
 golang.org/x/net v0.0.0-20220706163947-c90051bbdb60/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.0.0-20220906165146-f3363e06e74c/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=
-golang.org/x/net v0.6.0 h1:L4ZwwTvKW9gr0ZMS1yrHD9GZhIuVjOBBnaKH+SPQK0Q=
 golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.9.0 h1:aWJ/m6xSmxWBx+V0XRHTlrYrPG56jKsLdTFmsSsCzOM=
+golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -557,8 +574,9 @@ golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=
+golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
@@ -572,8 +590,9 @@ golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.7.0 h1:4BRB4x83lYWy72KwLD/qYDuTu7q9PjSagHvijDw7cLo=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
@@ -718,8 +737,8 @@ google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp0
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
-google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w=
-google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng=
+google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
--- a/log/logger.go
+++ b/log/logger.go
@@ -3,87 +3,20 @@
 package log

 import (
-	"os"
-	"path"
-	"runtime"
-	"strconv"
-	"sync"
-
+	"github.com/manyakrus/starter/logger"
 	//"github.com/google/logger"
 	//"github.com/sirupsen/logrus"
 	logrus "github.com/ManyakRus/logrus"
-
-	"github.com/manyakrus/starter/micro"
 )

-// log - глобальный логгер приложения
-var log *logrus.Logger
-
-// onceLog - гарантирует единственное создание логгера
-var onceLog sync.Once
-
 // GetLog - возвращает глобальный логгер приложения
 // и создаёт логгер если ещё не создан
 func GetLog() *logrus.Logger {
-	onceLog.Do(func() {

-		log = logrus.New()
-		log.SetReportCaller(true)
-
-		Formatter := new(logrus.TextFormatter)
-		Formatter.TimestampFormat = "2006-01-02 15:04:05.000"
-		Formatter.FullTimestamp = true
-		Formatter.CallerPrettyfier = CallerPrettyfier
-		log.SetFormatter(Formatter)
-
-		LOG_LEVEL := os.Getenv("LOG_LEVEL")
-		SetLevel(LOG_LEVEL)
-
-		//LOG_FILE := "log.txt"
-		//file, err := os.OpenFile(LOG_FILE, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0755)
-		//if err != nil {
-		//	log.Fatal(err)
-		//}
-		////defer file.Close()
-		//
-		//mw := io.MultiWriter(os.Stderr, file)
-		//logrus.SetOutput(mw)
-
-		//log.SetOutput(os.Stdout)
-		//log.SetOutput(file)
-
-	})
-
-	return log
-}
-
-// CallerPrettyfier - форматирует имя файла и номер строки кода
-func CallerPrettyfier(frame *runtime.Frame) (function string, file string) {
-	fileName := " " + path.Base(frame.File) + ":" + strconv.Itoa(frame.Line) + "\t"
-	FunctionName := frame.Function
-	FunctionName = micro.LastWord(FunctionName)
-	FunctionName = FunctionName + "()" + "\t"
-	return FunctionName, fileName
+	return logger.GetLog()
 }

 // SetLevel - изменяет уровень логирования
 func SetLevel(LOG_LEVEL string) {
-	if log == nil {
-		GetLog()
-	}
-
-	if LOG_LEVEL == "" {
-		LOG_LEVEL = "info"
-	}
-	level, err := logrus.ParseLevel(LOG_LEVEL)
-	if err != nil {
-		log.Error("logrus.ParseLevel() error: ", err)
-	}
-
-	if level == log.Level {
-		return
-	}
-
-	log.SetLevel(level)
-	log.Debug("new level: ", LOG_LEVEL)
+	logger.SetLevel(LOG_LEVEL)
 }
--- a/log/logger_proxy.go
+++ b/log/logger_proxy.go
@@ -4,6 +4,7 @@ package log
 import (
 	"context"
 	"github.com/ManyakRus/logrus"
+	"github.com/manyakrus/starter/logger"
 	"io"
 	"time"
 )
@@ -13,249 +14,204 @@ import (
 // this new returned entry.
 // If you want multiple fields, use `WithFields`.
 func WithField(key string, value interface{}) *logrus.Entry {
-	return log.WithField(key, value)
+	return logger.GetLog().WithField(key, value)
 }

 // Adds a struct of fields to the log entry. All it does is call `WithField` for
 // each `Field`.
 func WithFields(fields logrus.Fields) *logrus.Entry {
-	GetLog()
-	return log.WithFields(fields)
+	return GetLog().WithFields(fields)
 }

 // Add an error as single field to the log entry.  All it does is call
 // `WithError` for the given `error`.
 func WithError(err error) *logrus.Entry {
-	GetLog()
-	return log.WithError(err)
+	return GetLog().WithError(err)
 }

 // Add a context to the log entry.
 func WithContext(ctx context.Context) *logrus.Entry {
-	GetLog()
-	return log.WithContext(ctx)
+	return GetLog().WithContext(ctx)
 }

 // Overrides the time of the log entry.
 func WithTime(t time.Time) *logrus.Entry {
-	GetLog()
-	return WithTime(t)
+
+	return GetLog().WithTime(t)
 }

 func Logf(level logrus.Level, format string, args ...interface{}) {
-	GetLog()
-	log.Logf(level, format, args...)
+	GetLog().Logf(level, format, args...)
 }

 func Tracef(format string, args ...interface{}) {
-	GetLog()
-	log.Tracef(format, args...)
+	GetLog().Tracef(format, args...)
 }

 func Debugf(format string, args ...interface{}) {
-	GetLog()
-	log.Debugf(format, args...)
+	GetLog().Debugf(format, args...)
 }

 func Infof(format string, args ...interface{}) {
-	GetLog()
-	log.Infof(format, args...)
+	GetLog().Infof(format, args...)
 }

 func Printf(format string, args ...interface{}) {
-	GetLog()
-	log.Printf(format, args...)
+	GetLog().Printf(format, args...)
 }

 func Warnf(format string, args ...interface{}) {
-	GetLog()
-	log.Warnf(format, args...)
+	GetLog().Warnf(format, args...)
 }

 func Warningf(format string, args ...interface{}) {
-	GetLog()
-	log.Warningf(format, args...)
+	GetLog().Warningf(format, args...)
 }

 func Errorf(format string, args ...interface{}) {
-	GetLog()
-	log.Errorf(format, args...)
+	GetLog().Errorf(format, args...)
 }

 func Fatalf(format string, args ...interface{}) {
-	GetLog()
-	log.Fatalf(format, args...)
+	GetLog().Fatalf(format, args...)
 }

 func Panicf(format string, args ...interface{}) {
-	GetLog()
-	log.Panicf(format, args...)
+	GetLog().Panicf(format, args...)
 }

 // Log will log a message at the level given as parameter.
 // Warning: using Log at Panic or Fatal level will not respectively Panic nor Exit.
 // For this behaviour Logger.Panic or Logger.Fatal should be used instead.
 func Log(level logrus.Level, args ...interface{}) {
-	GetLog()
-	log.Log(level, args...)
+	GetLog().Log(level, args...)
 }

 func LogFn(level logrus.Level, fn logrus.LogFunction) {
-	GetLog()
-	log.LogFn(level, fn)
+	GetLog().LogFn(level, fn)
 }

 func Trace(args ...interface{}) {
-	GetLog()
-	log.Trace(args...)
+	GetLog().Trace(args...)
 }

 func Debug(args ...interface{}) {
-	GetLog()
-	log.Debug(args...)
+	GetLog().Debug(args...)
 }

 func Info(args ...interface{}) {
-	GetLog()
-	log.Info(args...)
+	GetLog().Info(args...)
 }

 func Print(args ...interface{}) {
-	GetLog()
-	log.Print(args...)
+	GetLog().Print(args...)
 }

 func Warn(args ...interface{}) {
-	GetLog()
-	log.Warn(args...)
+	GetLog().Warn(args...)
 }

 func Warning(args ...interface{}) {
-	GetLog()
-	log.Warning(args...)
+	GetLog().Warning(args...)
 }

 func Error(args ...interface{}) {
-	GetLog()
-	log.Error(args...)
+	GetLog().Error(args...)
 }

 func Fatal(args ...interface{}) {
-	GetLog()
-	log.Fatal(args...)
+	GetLog().Fatal(args...)
 }

 func Panic(args ...interface{}) {
-	GetLog()
-	log.Panic(args...)
+	GetLog().Panic(args...)
 }

 func TraceFn(fn logrus.LogFunction) {
-	GetLog()
-	log.TraceFn(fn)
+	GetLog().TraceFn(fn)
 }

 func DebugFn(fn logrus.LogFunction) {
-	GetLog()
-	log.DebugFn(fn)
+	GetLog().DebugFn(fn)
 }

 func InfoFn(fn logrus.LogFunction) {
-	GetLog()
-	log.InfoFn(fn)
+	GetLog().InfoFn(fn)
 }

 func PrintFn(fn logrus.LogFunction) {
-	GetLog()
-	log.PrintFn(fn)
+	GetLog().PrintFn(fn)
 }

 func WarnFn(fn logrus.LogFunction) {
-	GetLog()
-	log.WarnFn(fn)
+	GetLog().WarnFn(fn)
 }

 func WarningFn(fn logrus.LogFunction) {
-	GetLog()
-	log.WarningFn(fn)
+	GetLog().WarningFn(fn)
 }

 func ErrorFn(fn logrus.LogFunction) {
-	GetLog()
-	log.ErrorFn(fn)
+	GetLog().ErrorFn(fn)
 }

 func FatalFn(fn logrus.LogFunction) {
-	GetLog()
-	log.FatalFn(fn)
+	GetLog().FatalFn(fn)
 }

 func PanicFn(fn logrus.LogFunction) {
-	GetLog()
-	log.PanicFn(fn)
+	GetLog().PanicFn(fn)
 }

 func Logln(level logrus.Level, args ...interface{}) {
-	GetLog()
-	log.Logln(level, args...)
+	GetLog().Logln(level, args...)
 }

 func Traceln(args ...interface{}) {
-	GetLog()
-	log.Traceln(args...)
+	GetLog().Traceln(args...)
 }

 func Debugln(args ...interface{}) {
-	GetLog()
-	log.Debugln(args...)
+	GetLog().Debugln(args...)
 }

 func Infoln(args ...interface{}) {
-	GetLog()
-	log.Infoln(args...)
+	GetLog().Infoln(args...)
 }

 func Println(args ...interface{}) {
-	GetLog()
-	log.Println(args...)
+	GetLog().Println(args...)
 }

 func Warnln(args ...interface{}) {
-	GetLog()
-	log.Warnln(args...)
+	GetLog().Warnln(args...)
 }

 func Warningln(args ...interface{}) {
-	GetLog()
-	log.Warningln(args...)
+	GetLog().Warningln(args...)
 }

 func Errorln(args ...interface{}) {
-	GetLog()
-	log.Errorln(args...)
+	GetLog().Errorln(args...)
 }

 func Fatalln(args ...interface{}) {
-	GetLog()
-	log.Fatalln(args...)
+	GetLog().Fatalln(args...)
 }

 func Panicln(args ...interface{}) {
-	GetLog()
-	log.Panicln(args...)
+	GetLog().Panicln(args...)
 }

 func Exit(code int) {
-	GetLog()
-	log.Exit(code)
+	GetLog().Exit(code)
 }

 //When file is opened with appending mode, it's safe to
 //write concurrently to a file (within 4k message on Linux).
 //In these cases user can choose to disable the lock.
 func SetNoLock() {
-	GetLog()
-	log.SetNoLock()
+	GetLog().SetNoLock()
 }

 //// SetLevel sets the logger level.
@@ -264,37 +220,31 @@ func SetNoLock() {

 // GetLevel returns the logger level.
 func GetLevel() logrus.Level {
-	GetLog()
-	return log.GetLevel()
+	return GetLog().GetLevel()
 }

 // AddHook adds a hook to the logger hooks.
 func AddHook(hook logrus.Hook) {
-	GetLog()
-	log.AddHook(hook)
+	GetLog().AddHook(hook)
 }

 // IsLevelEnabled checks if the log level of the logger is greater than the level param
 func IsLevelEnabled(level logrus.Level) bool {
-	GetLog()
-	return log.IsLevelEnabled(level)
+	return GetLog().IsLevelEnabled(level)
 }

 // SetFormatter sets the logger formatter.
 func SetFormatter(formatter logrus.Formatter) {
-	GetLog()
-	log.SetFormatter(formatter)
+	GetLog().SetFormatter(formatter)
 }

 // SetOutput sets the logger output.
 func SetOutput(output io.Writer) {
-	GetLog()
-	log.SetOutput(output)
+	GetLog().SetOutput(output)
 }

 func SetReportCaller(reportCaller bool) {
-	GetLog()
-	log.SetReportCaller(reportCaller)
+	GetLog().SetReportCaller(reportCaller)
 }

 // ReplaceHooks replaces the logger hooks and returns the old ones
@@ -305,6 +255,5 @@ func ReplaceHooks(hooks logrus.LevelHooks) logrus.LevelHooks {

 // SetBufferPool sets the logger buffer pool.
 func SetBufferPool(pool logrus.BufferPool) {
-	GetLog()
-	log.SetBufferPool(pool)
+	GetLog().SetBufferPool(pool)
 }
--- a/micro/microfunctions.go
+++ b/micro/microfunctions.go
@@ -3,6 +3,7 @@
 package micro

 import (
+	"context"
 	"errors"
 	"fmt"
 	"runtime"
@@ -320,3 +321,30 @@ func MinInt64(x, y int64) int64 {
 	}
 	return x
 }
+
+// GoGo - запускает функцию в отдельном потоке
+func GoGo(ctx context.Context, fn func() error) error {
+	var err error
+	chanErr := make(chan error)
+
+	go gogo_chan(fn, chanErr)
+
+	select {
+	case <-ctx.Done():
+		Text1 := "error: TimeOut"
+		err = errors.New(Text1)
+		return err
+	case err = <-chanErr:
+		//print("err: ", err)
+		break
+	}
+
+	return err
+}
+
+// gogo_chan - запускает функцию и возвращает ошибку в поток
+// только совместно с GoGo()
+func gogo_chan(fn func() error, chanErr chan error) {
+	err := fn()
+	chanErr <- err
+}
--- a/micro/microfunctions_test.go
+++ b/micro/microfunctions_test.go
@@ -1,7 +1,10 @@
 package micro

 import (
+	"context"
 	"errors"
+	"fmt"
+	"github.com/manyakrus/starter/contextmain"
 	"os"
 	"testing"
 	"time"
@@ -211,3 +214,18 @@ func TestMinInt64(t *testing.T) {
 		t.Error("microfunctions_test.TestMin() error: Otvet != 1")
 	}
 }
+
+func TestGoGo(t *testing.T) {
+	fn := func() error {
+		Pause(2000)
+		err := fmt.Errorf("test error")
+		return err
+	}
+
+	ctxMain := contextmain.GetContext()
+	ctx, cancel := context.WithTimeout(ctxMain, 1*time.Second)
+	defer cancel()
+
+	err := GoGo(ctx, fn)
+	t.Log("Err:", err)
+}
--- a/mssql_connect/mssql_connect.go
+++ b/mssql_connect/mssql_connect.go
@@ -7,7 +7,6 @@ import (
 	"errors"
 	"fmt"
 	"github.com/jmoiron/sqlx"
-	"github.com/manyakrus/starter/logger"
 	"net/url"
 	"os"
 	"sync"
@@ -15,6 +14,7 @@ import (
 	_ "github.com/denisenkom/go-mssqldb"

 	"github.com/manyakrus/starter/contextmain"
+	"github.com/manyakrus/starter/logger"
 	"github.com/manyakrus/starter/micro"
 	"github.com/manyakrus/starter/stopapp"
 )
--- a/vendor/github.com/ManyakRus/logrus/entry.go
+++ b/vendor/github.com/ManyakRus/logrus/entry.go
@@ -203,7 +203,7 @@ func getCaller() *runtime.Frame {
 		pkg := getPackageName(f.Function)

 		// If the caller isn't part of this package, we're done
-		if pkg != logrusPackage && (f.File[len(f.File)-15-1:] != "/logger_proxy.go") { //sanek
+		if pkg != logrusPackage && (f.File[len(f.File)-15:] != "logger_proxy.go") { //sanek
 			return &f //nolint:scopelint
 		}
 	}
--- a/vendor/github.com/emersion/go-imap/.build.yml
+++ b/vendor/github.com/emersion/go-imap/.build.yml
@@ -0,0 +1,17 @@
+image: alpine/edge
+packages:
+  - go
+sources:
+  - https://github.com/emersion/go-imap
+artifacts:
+  - coverage.html
+tasks:
+  - build: |
+      cd go-imap
+      go build -race -v ./...
+  - test: |
+      cd go-imap
+      go test -coverprofile=coverage.txt -covermode=atomic ./...
+  - coverage: |
+      cd go-imap
+      go tool cover -html=coverage.txt -o ~/coverage.html
--- a/vendor/github.com/emersion/go-imap/.gitignore
+++ b/vendor/github.com/emersion/go-imap/.gitignore
@@ -0,0 +1,28 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof
+
+/client.go
+/server.go
+coverage.txt
--- a/vendor/github.com/emersion/go-imap/LICENSE
+++ b/vendor/github.com/emersion/go-imap/LICENSE
@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 The Go-IMAP Authors
+Copyright (c) 2016 emersion
+Copyright (c) 2016 Proton Technologies AG
+
+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.
--- a/vendor/github.com/emersion/go-imap/README.md
+++ b/vendor/github.com/emersion/go-imap/README.md
@@ -0,0 +1,178 @@
+# go-imap
+
+[![godocs.io](https://godocs.io/github.com/emersion/go-imap?status.svg)](https://godocs.io/github.com/emersion/go-imap)
+[![builds.sr.ht status](https://builds.sr.ht/~emersion/go-imap/commits/master.svg)](https://builds.sr.ht/~emersion/go-imap/commits/master?)
+
+An [IMAP4rev1](https://tools.ietf.org/html/rfc3501) library written in Go. It
+can be used to build a client and/or a server.
+
+## Usage
+
+### Client [![godocs.io](https://godocs.io/github.com/emersion/go-imap/client?status.svg)](https://godocs.io/github.com/emersion/go-imap/client)
+
+```go
+package main
+
+import (
+	"log"
+
+	"github.com/emersion/go-imap/client"
+	"github.com/emersion/go-imap"
+)
+
+func main() {
+	log.Println("Connecting to server...")
+
+	// Connect to server
+	c, err := client.DialTLS("mail.example.org:993", nil)
+	if err != nil {
+		log.Fatal(err)
+	}
+	log.Println("Connected")
+
+	// Don't forget to logout
+	defer c.Logout()
+
+	// Login
+	if err := c.Login("username", "password"); err != nil {
+		log.Fatal(err)
+	}
+	log.Println("Logged in")
+
+	// List mailboxes
+	mailboxes := make(chan *imap.MailboxInfo, 10)
+	done := make(chan error, 1)
+	go func () {
+		done <- c.List("", "*", mailboxes)
+	}()
+
+	log.Println("Mailboxes:")
+	for m := range mailboxes {
+		log.Println("* " + m.Name)
+	}
+
+	if err := <-done; err != nil {
+		log.Fatal(err)
+	}
+
+	// Select INBOX
+	mbox, err := c.Select("INBOX", false)
+	if err != nil {
+		log.Fatal(err)
+	}
+	log.Println("Flags for INBOX:", mbox.Flags)
+
+	// Get the last 4 messages
+	from := uint32(1)
+	to := mbox.Messages
+	if mbox.Messages > 3 {
+		// We're using unsigned integers here, only subtract if the result is > 0
+		from = mbox.Messages - 3
+	}
+	seqset := new(imap.SeqSet)
+	seqset.AddRange(from, to)
+
+	messages := make(chan *imap.Message, 10)
+	done = make(chan error, 1)
+	go func() {
+		done <- c.Fetch(seqset, []imap.FetchItem{imap.FetchEnvelope}, messages)
+	}()
+
+	log.Println("Last 4 messages:")
+	for msg := range messages {
+		log.Println("* " + msg.Envelope.Subject)
+	}
+
+	if err := <-done; err != nil {
+		log.Fatal(err)
+	}
+
+	log.Println("Done!")
+}
+```
+
+### Server [![godocs.io](https://godocs.io/github.com/emersion/go-imap/server?status.svg)](https://godocs.io/github.com/emersion/go-imap/server)
+
+```go
+package main
+
+import (
+	"log"
+
+	"github.com/emersion/go-imap/server"
+	"github.com/emersion/go-imap/backend/memory"
+)
+
+func main() {
+	// Create a memory backend
+	be := memory.New()
+
+	// Create a new server
+	s := server.New(be)
+	s.Addr = ":1143"
+	// Since we will use this server for testing only, we can allow plain text
+	// authentication over unencrypted connections
+	s.AllowInsecureAuth = true
+
+	log.Println("Starting IMAP server at localhost:1143")
+	if err := s.ListenAndServe(); err != nil {
+		log.Fatal(err)
+	}
+}
+```
+
+You can now use `telnet localhost 1143` to manually connect to the server.
+
+## Extensions
+
+Support for several IMAP extensions is included in go-imap itself. This
+includes:
+
+* [APPENDLIMIT](https://tools.ietf.org/html/rfc7889)
+* [CHILDREN](https://tools.ietf.org/html/rfc3348)
+* [ENABLE](https://tools.ietf.org/html/rfc5161)
+* [IDLE](https://tools.ietf.org/html/rfc2177)
+* [IMPORTANT](https://tools.ietf.org/html/rfc8457)
+* [LITERAL+](https://tools.ietf.org/html/rfc7888)
+* [MOVE](https://tools.ietf.org/html/rfc6851)
+* [SASL-IR](https://tools.ietf.org/html/rfc4959)
+* [SPECIAL-USE](https://tools.ietf.org/html/rfc6154)
+* [UNSELECT](https://tools.ietf.org/html/rfc3691)
+
+Support for other extensions is provided via separate packages. See below.
+
+## Extending go-imap
+
+### Extensions
+
+Commands defined in IMAP extensions are available in other packages. See [the
+wiki](https://github.com/emersion/go-imap/wiki/Using-extensions#using-client-extensions)
+to learn how to use them.
+
+* [COMPRESS](https://github.com/emersion/go-imap-compress)
+* [ID](https://github.com/ProtonMail/go-imap-id)
+* [METADATA](https://github.com/emersion/go-imap-metadata)
+* [NAMESPACE](https://github.com/foxcpp/go-imap-namespace)
+* [QUOTA](https://github.com/emersion/go-imap-quota)
+* [SORT and THREAD](https://github.com/emersion/go-imap-sortthread)
+* [UIDPLUS](https://github.com/emersion/go-imap-uidplus)
+
+### Server backends
+
+* [Memory](https://github.com/emersion/go-imap/tree/master/backend/memory) (for testing)
+* [Multi](https://github.com/emersion/go-imap-multi)
+* [PGP](https://github.com/emersion/go-imap-pgp)
+* [Proxy](https://github.com/emersion/go-imap-proxy)
+* [Notmuch](https://github.com/stbenjam/go-imap-notmuch) - Experimental gateway for [Notmuch](https://notmuchmail.org/)
+
+### Related projects
+
+* [go-message](https://github.com/emersion/go-message) - parsing and formatting MIME and mail messages
+* [go-msgauth](https://github.com/emersion/go-msgauth) - handle DKIM, DMARC and Authentication-Results
+* [go-pgpmail](https://github.com/emersion/go-pgpmail) - decrypting and encrypting mails with OpenPGP
+* [go-sasl](https://github.com/emersion/go-sasl) - sending and receiving SASL authentications
+* [go-smtp](https://github.com/emersion/go-smtp) - building SMTP clients and servers
+
+## License
+
+MIT
--- a/vendor/github.com/emersion/go-imap/client/client.go
+++ b/vendor/github.com/emersion/go-imap/client/client.go
@@ -0,0 +1,689 @@
+// Package client provides an IMAP client.
+//
+// It is not safe to use the same Client from multiple goroutines. In general,
+// the IMAP protocol doesn't make it possible to send multiple independent
+// IMAP commands on the same connection.
+package client
+
+import (
+	"crypto/tls"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"os"
+	"sync"
+	"time"
+
+	"github.com/emersion/go-imap"
+	"github.com/emersion/go-imap/commands"
+	"github.com/emersion/go-imap/responses"
+)
+
+// errClosed is used when a connection is closed while waiting for a command
+// response.
+var errClosed = fmt.Errorf("imap: connection closed")
+
+// errUnregisterHandler is returned by a response handler to unregister itself.
+var errUnregisterHandler = fmt.Errorf("imap: unregister handler")
+
+// Update is an unilateral server update.
+type Update interface {
+	update()
+}
+
+// StatusUpdate is delivered when a status update is received.
+type StatusUpdate struct {
+	Status *imap.StatusResp
+}
+
+func (u *StatusUpdate) update() {}
+
+// MailboxUpdate is delivered when a mailbox status changes.
+type MailboxUpdate struct {
+	Mailbox *imap.MailboxStatus
+}
+
+func (u *MailboxUpdate) update() {}
+
+// ExpungeUpdate is delivered when a message is deleted.
+type ExpungeUpdate struct {
+	SeqNum uint32
+}
+
+func (u *ExpungeUpdate) update() {}
+
+// MessageUpdate is delivered when a message attribute changes.
+type MessageUpdate struct {
+	Message *imap.Message
+}
+
+func (u *MessageUpdate) update() {}
+
+// Client is an IMAP client.
+type Client struct {
+	conn       *imap.Conn
+	isTLS      bool
+	serverName string
+
+	loggedOut chan struct{}
+	continues chan<- bool
+	upgrading bool
+
+	handlers       []responses.Handler
+	handlersLocker sync.Mutex
+
+	// The current connection state.
+	state imap.ConnState
+	// The selected mailbox, if there is one.
+	mailbox *imap.MailboxStatus
+	// The cached server capabilities.
+	caps map[string]bool
+	// state, mailbox and caps may be accessed in different goroutines. Protect
+	// access.
+	locker sync.Mutex
+
+	// A channel to which unilateral updates from the server will be sent. An
+	// update can be one of: *StatusUpdate, *MailboxUpdate, *MessageUpdate,
+	// *ExpungeUpdate. Note that blocking this channel blocks the whole client,
+	// so it's recommended to use a separate goroutine and a buffered channel to
+	// prevent deadlocks.
+	Updates chan<- Update
+
+	// ErrorLog specifies an optional logger for errors accepting connections and
+	// unexpected behavior from handlers. By default, logging goes to os.Stderr
+	// via the log package's standard logger. The logger must be safe to use
+	// simultaneously from multiple goroutines.
+	ErrorLog imap.Logger
+
+	// Timeout specifies a maximum amount of time to wait on a command.
+	//
+	// A Timeout of zero means no timeout. This is the default.
+	Timeout time.Duration
+}
+
+func (c *Client) registerHandler(h responses.Handler) {
+	if h == nil {
+		return
+	}
+
+	c.handlersLocker.Lock()
+	c.handlers = append(c.handlers, h)
+	c.handlersLocker.Unlock()
+}
+
+func (c *Client) handle(resp imap.Resp) error {
+	c.handlersLocker.Lock()
+	for i := len(c.handlers) - 1; i >= 0; i-- {
+		if err := c.handlers[i].Handle(resp); err != responses.ErrUnhandled {
+			if err == errUnregisterHandler {
+				c.handlers = append(c.handlers[:i], c.handlers[i+1:]...)
+				err = nil
+			}
+			c.handlersLocker.Unlock()
+			return err
+		}
+	}
+	c.handlersLocker.Unlock()
+	return responses.ErrUnhandled
+}
+
+func (c *Client) reader() {
+	defer close(c.loggedOut)
+	// Loop while connected.
+	for {
+		connected, err := c.readOnce()
+		if err != nil {
+			c.ErrorLog.Println("error reading response:", err)
+		}
+		if !connected {
+			return
+		}
+	}
+}
+
+func (c *Client) readOnce() (bool, error) {
+	if c.State() == imap.LogoutState {
+		return false, nil
+	}
+
+	resp, err := imap.ReadResp(c.conn.Reader)
+	if err == io.EOF || c.State() == imap.LogoutState {
+		return false, nil
+	} else if err != nil {
+		if imap.IsParseError(err) {
+			return true, err
+		} else {
+			return false, err
+		}
+	}
+
+	if err := c.handle(resp); err != nil && err != responses.ErrUnhandled {
+		c.ErrorLog.Println("cannot handle response ", resp, err)
+	}
+	return true, nil
+}
+
+func (c *Client) writeReply(reply []byte) error {
+	if _, err := c.conn.Writer.Write(reply); err != nil {
+		return err
+	}
+	// Flush reply
+	return c.conn.Writer.Flush()
+}
+
+type handleResult struct {
+	status *imap.StatusResp
+	err    error
+}
+
+func (c *Client) execute(cmdr imap.Commander, h responses.Handler) (*imap.StatusResp, error) {
+	cmd := cmdr.Command()
+	cmd.Tag = generateTag()
+
+	var replies <-chan []byte
+	if replier, ok := h.(responses.Replier); ok {
+		replies = replier.Replies()
+	}
+
+	if c.Timeout > 0 {
+		err := c.conn.SetDeadline(time.Now().Add(c.Timeout))
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		// It's possible the client had a timeout set from a previous command, but no
+		// longer does. Ensure we respect that. The zero time means no deadline.
+		if err := c.conn.SetDeadline(time.Time{}); err != nil {
+			return nil, err
+		}
+	}
+
+	// Check if we are upgrading.
+	upgrading := c.upgrading
+
+	// Add handler before sending command, to be sure to get the response in time
+	// (in tests, the response is sent right after our command is received, so
+	// sometimes the response was received before the setup of this handler)
+	doneHandle := make(chan handleResult, 1)
+	unregister := make(chan struct{})
+	c.registerHandler(responses.HandlerFunc(func(resp imap.Resp) error {
+		select {
+		case <-unregister:
+			// If an error occured while sending the command, abort
+			return errUnregisterHandler
+		default:
+		}
+
+		if s, ok := resp.(*imap.StatusResp); ok && s.Tag == cmd.Tag {
+			// This is the command's status response, we're done
+			doneHandle <- handleResult{s, nil}
+			// Special handling of connection upgrading.
+			if upgrading {
+				c.upgrading = false
+				// Wait for upgrade to finish.
+				c.conn.Wait()
+			}
+			// Cancel any pending literal write
+			select {
+			case c.continues <- false:
+			default:
+			}
+			return errUnregisterHandler
+		}
+
+		if h != nil {
+			// Pass the response to the response handler
+			if err := h.Handle(resp); err != nil && err != responses.ErrUnhandled {
+				// If the response handler returns an error, abort
+				doneHandle <- handleResult{nil, err}
+				return errUnregisterHandler
+			} else {
+				return err
+			}
+		}
+		return responses.ErrUnhandled
+	}))
+
+	// Send the command to the server
+	if err := cmd.WriteTo(c.conn.Writer); err != nil {
+		// Error while sending the command
+		close(unregister)
+
+		if err, ok := err.(imap.LiteralLengthErr); ok {
+			// Expected > Actual
+			//  The server is waiting for us to write
+			//  more bytes, we don't have them. Run.
+			// Expected < Actual
+			//  We are about to send a potentially truncated message, we don't
+			//  want this (ths terminating CRLF is not sent at this point).
+			c.conn.Close()
+			return nil, err
+		}
+
+		return nil, err
+	}
+	// Flush writer if we are upgrading
+	if upgrading {
+		if err := c.conn.Writer.Flush(); err != nil {
+			// Error while sending the command
+			close(unregister)
+			return nil, err
+		}
+	}
+
+	for {
+		select {
+		case reply := <-replies:
+			// Response handler needs to send a reply (Used for AUTHENTICATE)
+			if err := c.writeReply(reply); err != nil {
+				close(unregister)
+				return nil, err
+			}
+		case <-c.loggedOut:
+			// If the connection is closed (such as from an I/O error), ensure we
+			// realize this and don't block waiting on a response that will never
+			// come. loggedOut is a channel that closes when the reader goroutine
+			// ends.
+			close(unregister)
+			return nil, errClosed
+		case result := <-doneHandle:
+			return result.status, result.err
+		}
+	}
+}
+
+// State returns the current connection state.
+func (c *Client) State() imap.ConnState {
+	c.locker.Lock()
+	state := c.state
+	c.locker.Unlock()
+	return state
+}
+
+// Mailbox returns the selected mailbox. It returns nil if there isn't one.
+func (c *Client) Mailbox() *imap.MailboxStatus {
+	// c.Mailbox fields are not supposed to change, so we can return the pointer.
+	c.locker.Lock()
+	mbox := c.mailbox
+	c.locker.Unlock()
+	return mbox
+}
+
+// SetState sets this connection's internal state.
+//
+// This function should not be called directly, it must only be used by
+// libraries implementing extensions of the IMAP protocol.
+func (c *Client) SetState(state imap.ConnState, mailbox *imap.MailboxStatus) {
+	c.locker.Lock()
+	c.state = state
+	c.mailbox = mailbox
+	c.locker.Unlock()
+}
+
+// Execute executes a generic command. cmdr is a value that can be converted to
+// a raw command and h is a response handler. The function returns when the
+// command has completed or failed, in this case err is nil. A non-nil err value
+// indicates a network error.
+//
+// This function should not be called directly, it must only be used by
+// libraries implementing extensions of the IMAP protocol.
+func (c *Client) Execute(cmdr imap.Commander, h responses.Handler) (*imap.StatusResp, error) {
+	return c.execute(cmdr, h)
+}
+
+func (c *Client) handleContinuationReqs() {
+	c.registerHandler(responses.HandlerFunc(func(resp imap.Resp) error {
+		if _, ok := resp.(*imap.ContinuationReq); ok {
+			go func() {
+				c.continues <- true
+			}()
+			return nil
+		}
+		return responses.ErrUnhandled
+	}))
+}
+
+func (c *Client) gotStatusCaps(args []interface{}) {
+	c.locker.Lock()
+
+	c.caps = make(map[string]bool)
+	for _, cap := range args {
+		if cap, ok := cap.(string); ok {
+			c.caps[cap] = true
+		}
+	}
+
+	c.locker.Unlock()
+}
+
+// The server can send unilateral data. This function handles it.
+func (c *Client) handleUnilateral() {
+	c.registerHandler(responses.HandlerFunc(func(resp imap.Resp) error {
+		switch resp := resp.(type) {
+		case *imap.StatusResp:
+			if resp.Tag != "*" {
+				return responses.ErrUnhandled
+			}
+
+			switch resp.Type {
+			case imap.StatusRespOk, imap.StatusRespNo, imap.StatusRespBad:
+				if c.Updates != nil {
+					c.Updates <- &StatusUpdate{resp}
+				}
+			case imap.StatusRespBye:
+				c.locker.Lock()
+				c.state = imap.LogoutState
+				c.mailbox = nil
+				c.locker.Unlock()
+
+				c.conn.Close()
+
+				if c.Updates != nil {
+					c.Updates <- &StatusUpdate{resp}
+				}
+			default:
+				return responses.ErrUnhandled
+			}
+		case *imap.DataResp:
+			name, fields, ok := imap.ParseNamedResp(resp)
+			if !ok {
+				return responses.ErrUnhandled
+			}
+
+			switch name {
+			case "CAPABILITY":
+				c.gotStatusCaps(fields)
+			case "EXISTS":
+				if c.Mailbox() == nil {
+					break
+				}
+
+				if messages, err := imap.ParseNumber(fields[0]); err == nil {
+					c.locker.Lock()
+					c.mailbox.Messages = messages
+					c.locker.Unlock()
+
+					c.mailbox.ItemsLocker.Lock()
+					c.mailbox.Items[imap.StatusMessages] = nil
+					c.mailbox.ItemsLocker.Unlock()
+				}
+
+				if c.Updates != nil {
+					c.Updates <- &MailboxUpdate{c.Mailbox()}
+				}
+			case "RECENT":
+				if c.Mailbox() == nil {
+					break
+				}
+
+				if recent, err := imap.ParseNumber(fields[0]); err == nil {
+					c.locker.Lock()
+					c.mailbox.Recent = recent
+					c.locker.Unlock()
+
+					c.mailbox.ItemsLocker.Lock()
+					c.mailbox.Items[imap.StatusRecent] = nil
+					c.mailbox.ItemsLocker.Unlock()
+				}
+
+				if c.Updates != nil {
+					c.Updates <- &MailboxUpdate{c.Mailbox()}
+				}
+			case "EXPUNGE":
+				seqNum, _ := imap.ParseNumber(fields[0])
+
+				if c.Updates != nil {
+					c.Updates <- &ExpungeUpdate{seqNum}
+				}
+			case "FETCH":
+				seqNum, _ := imap.ParseNumber(fields[0])
+				fields, _ := fields[1].([]interface{})
+
+				msg := &imap.Message{SeqNum: seqNum}
+				if err := msg.Parse(fields); err != nil {
+					break
+				}
+
+				if c.Updates != nil {
+					c.Updates <- &MessageUpdate{msg}
+				}
+			default:
+				return responses.ErrUnhandled
+			}
+		default:
+			return responses.ErrUnhandled
+		}
+		return nil
+	}))
+}
+
+func (c *Client) handleGreetAndStartReading() error {
+	var greetErr error
+	gotGreet := false
+
+	c.registerHandler(responses.HandlerFunc(func(resp imap.Resp) error {
+		status, ok := resp.(*imap.StatusResp)
+		if !ok {
+			greetErr = fmt.Errorf("invalid greeting received from server: not a status response")
+			return errUnregisterHandler
+		}
+
+		c.locker.Lock()
+		switch status.Type {
+		case imap.StatusRespPreauth:
+			c.state = imap.AuthenticatedState
+		case imap.StatusRespBye:
+			c.state = imap.LogoutState
+		case imap.StatusRespOk:
+			c.state = imap.NotAuthenticatedState
+		default:
+			c.state = imap.LogoutState
+			c.locker.Unlock()
+			greetErr = fmt.Errorf("invalid greeting received from server: %v", status.Type)
+			return errUnregisterHandler
+		}
+		c.locker.Unlock()
+
+		if status.Code == imap.CodeCapability {
+			c.gotStatusCaps(status.Arguments)
+		}
+
+		gotGreet = true
+		return errUnregisterHandler
+	}))
+
+	// call `readOnce` until we get the greeting or an error
+	for !gotGreet {
+		connected, err := c.readOnce()
+		// Check for read errors
+		if err != nil {
+			// return read errors
+			return err
+		}
+		// Check for invalid greet
+		if greetErr != nil {
+			// return read errors
+			return greetErr
+		}
+		// Check if connection was closed.
+		if !connected {
+			// connection closed.
+			return io.EOF
+		}
+	}
+
+	// We got the greeting, now start the reader goroutine.
+	go c.reader()
+
+	return nil
+}
+
+// Upgrade a connection, e.g. wrap an unencrypted connection with an encrypted
+// tunnel.
+//
+// This function should not be called directly, it must only be used by
+// libraries implementing extensions of the IMAP protocol.
+func (c *Client) Upgrade(upgrader imap.ConnUpgrader) error {
+	return c.conn.Upgrade(upgrader)
+}
+
+// Writer returns the imap.Writer for this client's connection.
+//
+// This function should not be called directly, it must only be used by
+// libraries implementing extensions of the IMAP protocol.
+func (c *Client) Writer() *imap.Writer {
+	return c.conn.Writer
+}
+
+// IsTLS checks if this client's connection has TLS enabled.
+func (c *Client) IsTLS() bool {
+	return c.isTLS
+}
+
+// LoggedOut returns a channel which is closed when the connection to the server
+// is closed.
+func (c *Client) LoggedOut() <-chan struct{} {
+	return c.loggedOut
+}
+
+// SetDebug defines an io.Writer to which all network activity will be logged.
+// If nil is provided, network activity will not be logged.
+func (c *Client) SetDebug(w io.Writer) {
+	// Need to send a command to unblock the reader goroutine.
+	cmd := new(commands.Noop)
+	err := c.Upgrade(func(conn net.Conn) (net.Conn, error) {
+		// Flag connection as in upgrading
+		c.upgrading = true
+		if status, err := c.execute(cmd, nil); err != nil {
+			return nil, err
+		} else if err := status.Err(); err != nil {
+			return nil, err
+		}
+
+		// Wait for reader to block.
+		c.conn.WaitReady()
+
+		c.conn.SetDebug(w)
+		return conn, nil
+	})
+	if err != nil {
+		log.Println("SetDebug:", err)
+	}
+
+}
+
+// New creates a new client from an existing connection.
+func New(conn net.Conn) (*Client, error) {
+	continues := make(chan bool)
+	w := imap.NewClientWriter(nil, continues)
+	r := imap.NewReader(nil)
+
+	c := &Client{
+		conn:      imap.NewConn(conn, r, w),
+		loggedOut: make(chan struct{}),
+		continues: continues,
+		state:     imap.ConnectingState,
+		ErrorLog:  log.New(os.Stderr, "imap/client: ", log.LstdFlags),
+	}
+
+	c.handleContinuationReqs()
+	c.handleUnilateral()
+	if err := c.handleGreetAndStartReading(); err != nil {
+		return c, err
+	}
+
+	plusOk, _ := c.Support("LITERAL+")
+	minusOk, _ := c.Support("LITERAL-")
+	// We don't use non-sync literal if it is bigger than 4096 bytes, so
+	// LITERAL- is fine too.
+	c.conn.AllowAsyncLiterals = plusOk || minusOk
+
+	return c, nil
+}
+
+// Dial connects to an IMAP server using an unencrypted connection.
+func Dial(addr string) (*Client, error) {
+	return DialWithDialer(new(net.Dialer), addr)
+}
+
+type Dialer interface {
+	// Dial connects to the given address.
+	Dial(network, addr string) (net.Conn, error)
+}
+
+// DialWithDialer connects to an IMAP server using an unencrypted connection
+// using dialer.Dial.
+//
+// Among other uses, this allows to apply a dial timeout.
+func DialWithDialer(dialer Dialer, addr string) (*Client, error) {
+	conn, err := dialer.Dial("tcp", addr)
+	if err != nil {
+		return nil, err
+	}
+
+	// We don't return to the caller until we try to receive a greeting. As such,
+	// there is no way to set the client's Timeout for that action. As a
+	// workaround, if the dialer has a timeout set, use that for the connection's
+	// deadline.
+	if netDialer, ok := dialer.(*net.Dialer); ok && netDialer.Timeout > 0 {
+		err := conn.SetDeadline(time.Now().Add(netDialer.Timeout))
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	c, err := New(conn)
+	if err != nil {
+		return nil, err
+	}
+
+	c.serverName, _, _ = net.SplitHostPort(addr)
+	return c, nil
+}
+
+// DialTLS connects to an IMAP server using an encrypted connection.
+func DialTLS(addr string, tlsConfig *tls.Config) (*Client, error) {
+	return DialWithDialerTLS(new(net.Dialer), addr, tlsConfig)
+}
+
+// DialWithDialerTLS connects to an IMAP server using an encrypted connection
+// using dialer.Dial.
+//
+// Among other uses, this allows to apply a dial timeout.
+func DialWithDialerTLS(dialer Dialer, addr string, tlsConfig *tls.Config) (*Client, error) {
+	conn, err := dialer.Dial("tcp", addr)
+	if err != nil {
+		return nil, err
+	}
+
+	serverName, _, _ := net.SplitHostPort(addr)
+	if tlsConfig == nil {
+		tlsConfig = &tls.Config{}
+	}
+	if tlsConfig.ServerName == "" {
+		tlsConfig = tlsConfig.Clone()
+		tlsConfig.ServerName = serverName
+	}
+	tlsConn := tls.Client(conn, tlsConfig)
+
+	// We don't return to the caller until we try to receive a greeting. As such,
+	// there is no way to set the client's Timeout for that action. As a
+	// workaround, if the dialer has a timeout set, use that for the connection's
+	// deadline.
+	if netDialer, ok := dialer.(*net.Dialer); ok && netDialer.Timeout > 0 {
+		err := tlsConn.SetDeadline(time.Now().Add(netDialer.Timeout))
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	c, err := New(tlsConn)
+	if err != nil {
+		return nil, err
+	}
+
+	c.isTLS = true
+	c.serverName = serverName
+	return c, nil
+}
--- a/vendor/github.com/emersion/go-imap/client/cmd_any.go
+++ b/vendor/github.com/emersion/go-imap/client/cmd_any.go
@@ -0,0 +1,88 @@
+package client
+
+import (
+	"errors"
+
+	"github.com/emersion/go-imap"
+	"github.com/emersion/go-imap/commands"
+)
+
+// ErrAlreadyLoggedOut is returned if Logout is called when the client is
+// already logged out.
+var ErrAlreadyLoggedOut = errors.New("Already logged out")
+
+// Capability requests a listing of capabilities that the server supports.
+// Capabilities are often returned by the server with the greeting or with the
+// STARTTLS and LOGIN responses, so usually explicitly requesting capabilities
+// isn't needed.
+//
+// Most of the time, Support should be used instead.
+func (c *Client) Capability() (map[string]bool, error) {
+	cmd := &commands.Capability{}
+
+	if status, err := c.execute(cmd, nil); err != nil {
+		return nil, err
+	} else if err := status.Err(); err != nil {
+		return nil, err
+	}
+
+	c.locker.Lock()
+	caps := c.caps
+	c.locker.Unlock()
+	return caps, nil
+}
+
+// Support checks if cap is a capability supported by the server. If the server
+// hasn't sent its capabilities yet, Support requests them.
+func (c *Client) Support(cap string) (bool, error) {
+	c.locker.Lock()
+	ok := c.caps != nil
+	c.locker.Unlock()
+
+	// If capabilities are not cached, request them
+	if !ok {
+		if _, err := c.Capability(); err != nil {
+			return false, err
+		}
+	}
+
+	c.locker.Lock()
+	supported := c.caps[cap]
+	c.locker.Unlock()
+
+	return supported, nil
+}
+
+// Noop always succeeds and does nothing.
+//
+// It can be used as a periodic poll for new messages or message status updates
+// during a period of inactivity. It can also be used to reset any inactivity
+// autologout timer on the server.
+func (c *Client) Noop() error {
+	cmd := new(commands.Noop)
+
+	status, err := c.execute(cmd, nil)
+	if err != nil {
+		return err
+	}
+	return status.Err()
+}
+
+// Logout gracefully closes the connection.
+func (c *Client) Logout() error {
+	if c.State() == imap.LogoutState {
+		return ErrAlreadyLoggedOut
+	}
+
+	cmd := new(commands.Logout)
+
+	if status, err := c.execute(cmd, nil); err == errClosed {
+		// Server closed connection, that's what we want anyway
+		return nil
+	} else if err != nil {
+		return err
+	} else if status != nil {
+		return status.Err()
+	}
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/client/cmd_auth.go
+++ b/vendor/github.com/emersion/go-imap/client/cmd_auth.go
@@ -0,0 +1,380 @@
+package client
+
+import (
+	"errors"
+	"time"
+
+	"github.com/emersion/go-imap"
+	"github.com/emersion/go-imap/commands"
+	"github.com/emersion/go-imap/responses"
+)
+
+// ErrNotLoggedIn is returned if a function that requires the client to be
+// logged in is called then the client isn't.
+var ErrNotLoggedIn = errors.New("Not logged in")
+
+func (c *Client) ensureAuthenticated() error {
+	state := c.State()
+	if state != imap.AuthenticatedState && state != imap.SelectedState {
+		return ErrNotLoggedIn
+	}
+	return nil
+}
+
+// Select selects a mailbox so that messages in the mailbox can be accessed. Any
+// currently selected mailbox is deselected before attempting the new selection.
+// Even if the readOnly parameter is set to false, the server can decide to open
+// the mailbox in read-only mode.
+func (c *Client) Select(name string, readOnly bool) (*imap.MailboxStatus, error) {
+	if err := c.ensureAuthenticated(); err != nil {
+		return nil, err
+	}
+
+	cmd := &commands.Select{
+		Mailbox:  name,
+		ReadOnly: readOnly,
+	}
+
+	mbox := &imap.MailboxStatus{Name: name, Items: make(map[imap.StatusItem]interface{})}
+	res := &responses.Select{
+		Mailbox: mbox,
+	}
+	c.locker.Lock()
+	c.mailbox = mbox
+	c.locker.Unlock()
+
+	status, err := c.execute(cmd, res)
+	if err != nil {
+		c.locker.Lock()
+		c.mailbox = nil
+		c.locker.Unlock()
+		return nil, err
+	}
+	if err := status.Err(); err != nil {
+		c.locker.Lock()
+		c.mailbox = nil
+		c.locker.Unlock()
+		return nil, err
+	}
+
+	c.locker.Lock()
+	mbox.ReadOnly = (status.Code == imap.CodeReadOnly)
+	c.state = imap.SelectedState
+	c.locker.Unlock()
+	return mbox, nil
+}
+
+// Create creates a mailbox with the given name.
+func (c *Client) Create(name string) error {
+	if err := c.ensureAuthenticated(); err != nil {
+		return err
+	}
+
+	cmd := &commands.Create{
+		Mailbox: name,
+	}
+
+	status, err := c.execute(cmd, nil)
+	if err != nil {
+		return err
+	}
+	return status.Err()
+}
+
+// Delete permanently removes the mailbox with the given name.
+func (c *Client) Delete(name string) error {
+	if err := c.ensureAuthenticated(); err != nil {
+		return err
+	}
+
+	cmd := &commands.Delete{
+		Mailbox: name,
+	}
+
+	status, err := c.execute(cmd, nil)
+	if err != nil {
+		return err
+	}
+	return status.Err()
+}
+
+// Rename changes the name of a mailbox.
+func (c *Client) Rename(existingName, newName string) error {
+	if err := c.ensureAuthenticated(); err != nil {
+		return err
+	}
+
+	cmd := &commands.Rename{
+		Existing: existingName,
+		New:      newName,
+	}
+
+	status, err := c.execute(cmd, nil)
+	if err != nil {
+		return err
+	}
+	return status.Err()
+}
+
+// Subscribe adds the specified mailbox name to the server's set of "active" or
+// "subscribed" mailboxes.
+func (c *Client) Subscribe(name string) error {
+	if err := c.ensureAuthenticated(); err != nil {
+		return err
+	}
+
+	cmd := &commands.Subscribe{
+		Mailbox: name,
+	}
+
+	status, err := c.execute(cmd, nil)
+	if err != nil {
+		return err
+	}
+	return status.Err()
+}
+
+// Unsubscribe removes the specified mailbox name from the server's set of
+// "active" or "subscribed" mailboxes.
+func (c *Client) Unsubscribe(name string) error {
+	if err := c.ensureAuthenticated(); err != nil {
+		return err
+	}
+
+	cmd := &commands.Unsubscribe{
+		Mailbox: name,
+	}
+
+	status, err := c.execute(cmd, nil)
+	if err != nil {
+		return err
+	}
+	return status.Err()
+}
+
+// List returns a subset of names from the complete set of all names available
+// to the client.
+//
+// An empty name argument is a special request to return the hierarchy delimiter
+// and the root name of the name given in the reference. The character "*" is a
+// wildcard, and matches zero or more characters at this position. The
+// character "%" is similar to "*", but it does not match a hierarchy delimiter.
+func (c *Client) List(ref, name string, ch chan *imap.MailboxInfo) error {
+	defer close(ch)
+
+	if err := c.ensureAuthenticated(); err != nil {
+		return err
+	}
+
+	cmd := &commands.List{
+		Reference: ref,
+		Mailbox:   name,
+	}
+	res := &responses.List{Mailboxes: ch}
+
+	status, err := c.execute(cmd, res)
+	if err != nil {
+		return err
+	}
+	return status.Err()
+}
+
+// Lsub returns a subset of names from the set of names that the user has
+// declared as being "active" or "subscribed".
+func (c *Client) Lsub(ref, name string, ch chan *imap.MailboxInfo) error {
+	defer close(ch)
+
+	if err := c.ensureAuthenticated(); err != nil {
+		return err
+	}
+
+	cmd := &commands.List{
+		Reference:  ref,
+		Mailbox:    name,
+		Subscribed: true,
+	}
+	res := &responses.List{
+		Mailboxes:  ch,
+		Subscribed: true,
+	}
+
+	status, err := c.execute(cmd, res)
+	if err != nil {
+		return err
+	}
+	return status.Err()
+}
+
+// Status requests the status of the indicated mailbox. It does not change the
+// currently selected mailbox, nor does it affect the state of any messages in
+// the queried mailbox.
+//
+// See RFC 3501 section 6.3.10 for a list of items that can be requested.
+func (c *Client) Status(name string, items []imap.StatusItem) (*imap.MailboxStatus, error) {
+	if err := c.ensureAuthenticated(); err != nil {
+		return nil, err
+	}
+
+	cmd := &commands.Status{
+		Mailbox: name,
+		Items:   items,
+	}
+	res := &responses.Status{
+		Mailbox: new(imap.MailboxStatus),
+	}
+
+	status, err := c.execute(cmd, res)
+	if err != nil {
+		return nil, err
+	}
+	return res.Mailbox, status.Err()
+}
+
+// Append appends the literal argument as a new message to the end of the
+// specified destination mailbox. This argument SHOULD be in the format of an
+// RFC 2822 message. flags and date are optional arguments and can be set to
+// nil and the empty struct.
+func (c *Client) Append(mbox string, flags []string, date time.Time, msg imap.Literal) error {
+	if err := c.ensureAuthenticated(); err != nil {
+		return err
+	}
+
+	cmd := &commands.Append{
+		Mailbox: mbox,
+		Flags:   flags,
+		Date:    date,
+		Message: msg,
+	}
+
+	status, err := c.execute(cmd, nil)
+	if err != nil {
+		return err
+	}
+	return status.Err()
+}
+
+// Enable requests the server to enable the named extensions. The extensions
+// which were successfully enabled are returned.
+//
+// See RFC 5161 section 3.1.
+func (c *Client) Enable(caps []string) ([]string, error) {
+	if ok, err := c.Support("ENABLE"); !ok || err != nil {
+		return nil, ErrExtensionUnsupported
+	}
+
+	// ENABLE is invalid if a mailbox has been selected.
+	if c.State() != imap.AuthenticatedState {
+		return nil, ErrNotLoggedIn
+	}
+
+	cmd := &commands.Enable{Caps: caps}
+	res := &responses.Enabled{}
+
+	if status, err := c.Execute(cmd, res); err != nil {
+		return nil, err
+	} else {
+		return res.Caps, status.Err()
+	}
+}
+
+func (c *Client) idle(stop <-chan struct{}) error {
+	cmd := &commands.Idle{}
+
+	res := &responses.Idle{
+		Stop:      stop,
+		RepliesCh: make(chan []byte, 10),
+	}
+
+	if status, err := c.Execute(cmd, res); err != nil {
+		return err
+	} else {
+		return status.Err()
+	}
+}
+
+// IdleOptions holds options for Client.Idle.
+type IdleOptions struct {
+	// LogoutTimeout is used to avoid being logged out by the server when
+	// idling. Each LogoutTimeout, the IDLE command is restarted. If set to
+	// zero, a default is used. If negative, this behavior is disabled.
+	LogoutTimeout time.Duration
+	// Poll interval when the server doesn't support IDLE. If zero, a default
+	// is used. If negative, polling is always disabled.
+	PollInterval time.Duration
+}
+
+// Idle indicates to the server that the client is ready to receive unsolicited
+// mailbox update messages. When the client wants to send commands again, it
+// must first close stop.
+//
+// If the server doesn't support IDLE, go-imap falls back to polling.
+func (c *Client) Idle(stop <-chan struct{}, opts *IdleOptions) error {
+	if ok, err := c.Support("IDLE"); err != nil {
+		return err
+	} else if !ok {
+		return c.idleFallback(stop, opts)
+	}
+
+	logoutTimeout := 25 * time.Minute
+	if opts != nil {
+		if opts.LogoutTimeout > 0 {
+			logoutTimeout = opts.LogoutTimeout
+		} else if opts.LogoutTimeout < 0 {
+			return c.idle(stop)
+		}
+	}
+
+	t := time.NewTicker(logoutTimeout)
+	defer t.Stop()
+
+	for {
+		stopOrRestart := make(chan struct{})
+		done := make(chan error, 1)
+		go func() {
+			done <- c.idle(stopOrRestart)
+		}()
+
+		select {
+		case <-t.C:
+			close(stopOrRestart)
+			if err := <-done; err != nil {
+				return err
+			}
+		case <-stop:
+			close(stopOrRestart)
+			return <-done
+		case err := <-done:
+			close(stopOrRestart)
+			if err != nil {
+				return err
+			}
+		}
+	}
+}
+
+func (c *Client) idleFallback(stop <-chan struct{}, opts *IdleOptions) error {
+	pollInterval := time.Minute
+	if opts != nil {
+		if opts.PollInterval > 0 {
+			pollInterval = opts.PollInterval
+		} else if opts.PollInterval < 0 {
+			return ErrExtensionUnsupported
+		}
+	}
+
+	t := time.NewTicker(pollInterval)
+	defer t.Stop()
+
+	for {
+		select {
+		case <-t.C:
+			if err := c.Noop(); err != nil {
+				return err
+			}
+		case <-stop:
+			return nil
+		case <-c.LoggedOut():
+			return errors.New("disconnected while idling")
+		}
+	}
+}
--- a/vendor/github.com/emersion/go-imap/client/cmd_noauth.go
+++ b/vendor/github.com/emersion/go-imap/client/cmd_noauth.go
@@ -0,0 +1,174 @@
+package client
+
+import (
+	"crypto/tls"
+	"errors"
+	"net"
+
+	"github.com/emersion/go-imap"
+	"github.com/emersion/go-imap/commands"
+	"github.com/emersion/go-imap/responses"
+	"github.com/emersion/go-sasl"
+)
+
+var (
+	// ErrAlreadyLoggedIn is returned if Login or Authenticate is called when the
+	// client is already logged in.
+	ErrAlreadyLoggedIn = errors.New("Already logged in")
+	// ErrTLSAlreadyEnabled is returned if StartTLS is called when TLS is already
+	// enabled.
+	ErrTLSAlreadyEnabled = errors.New("TLS is already enabled")
+	// ErrLoginDisabled is returned if Login or Authenticate is called when the
+	// server has disabled authentication. Most of the time, calling enabling TLS
+	// solves the problem.
+	ErrLoginDisabled = errors.New("Login is disabled in current state")
+)
+
+// SupportStartTLS checks if the server supports STARTTLS.
+func (c *Client) SupportStartTLS() (bool, error) {
+	return c.Support("STARTTLS")
+}
+
+// StartTLS starts TLS negotiation.
+func (c *Client) StartTLS(tlsConfig *tls.Config) error {
+	if c.isTLS {
+		return ErrTLSAlreadyEnabled
+	}
+
+	if tlsConfig == nil {
+		tlsConfig = new(tls.Config)
+	}
+	if tlsConfig.ServerName == "" {
+		tlsConfig = tlsConfig.Clone()
+		tlsConfig.ServerName = c.serverName
+	}
+
+	cmd := new(commands.StartTLS)
+
+	err := c.Upgrade(func(conn net.Conn) (net.Conn, error) {
+		// Flag connection as in upgrading
+		c.upgrading = true
+		if status, err := c.execute(cmd, nil); err != nil {
+			return nil, err
+		} else if err := status.Err(); err != nil {
+			return nil, err
+		}
+
+		// Wait for reader to block.
+		c.conn.WaitReady()
+		tlsConn := tls.Client(conn, tlsConfig)
+		if err := tlsConn.Handshake(); err != nil {
+			return nil, err
+		}
+
+		// Capabilities change when TLS is enabled
+		c.locker.Lock()
+		c.caps = nil
+		c.locker.Unlock()
+
+		return tlsConn, nil
+	})
+	if err != nil {
+		return err
+	}
+
+	c.isTLS = true
+	return nil
+}
+
+// SupportAuth checks if the server supports a given authentication mechanism.
+func (c *Client) SupportAuth(mech string) (bool, error) {
+	return c.Support("AUTH=" + mech)
+}
+
+// Authenticate indicates a SASL authentication mechanism to the server. If the
+// server supports the requested authentication mechanism, it performs an
+// authentication protocol exchange to authenticate and identify the client.
+func (c *Client) Authenticate(auth sasl.Client) error {
+	if c.State() != imap.NotAuthenticatedState {
+		return ErrAlreadyLoggedIn
+	}
+
+	mech, ir, err := auth.Start()
+	if err != nil {
+		return err
+	}
+
+	cmd := &commands.Authenticate{
+		Mechanism: mech,
+	}
+
+	irOk, err := c.Support("SASL-IR")
+	if err != nil {
+		return err
+	}
+	if irOk {
+		cmd.InitialResponse = ir
+	}
+
+	res := &responses.Authenticate{
+		Mechanism:       auth,
+		InitialResponse: ir,
+		RepliesCh:       make(chan []byte, 10),
+	}
+	if irOk {
+		res.InitialResponse = nil
+	}
+
+	status, err := c.execute(cmd, res)
+	if err != nil {
+		return err
+	}
+	if err = status.Err(); err != nil {
+		return err
+	}
+
+	c.locker.Lock()
+	c.state = imap.AuthenticatedState
+	c.caps = nil // Capabilities change when user is logged in
+	c.locker.Unlock()
+
+	if status.Code == "CAPABILITY" {
+		c.gotStatusCaps(status.Arguments)
+	}
+
+	return nil
+}
+
+// Login identifies the client to the server and carries the plaintext password
+// authenticating this user.
+func (c *Client) Login(username, password string) error {
+	if state := c.State(); state == imap.AuthenticatedState || state == imap.SelectedState {
+		return ErrAlreadyLoggedIn
+	}
+
+	c.locker.Lock()
+	loginDisabled := c.caps != nil && c.caps["LOGINDISABLED"]
+	c.locker.Unlock()
+	if loginDisabled {
+		return ErrLoginDisabled
+	}
+
+	cmd := &commands.Login{
+		Username: username,
+		Password: password,
+	}
+
+	status, err := c.execute(cmd, nil)
+	if err != nil {
+		return err
+	}
+	if err = status.Err(); err != nil {
+		return err
+	}
+
+	c.locker.Lock()
+	c.state = imap.AuthenticatedState
+	c.caps = nil // Capabilities change when user is logged in
+	c.locker.Unlock()
+
+	if status.Code == "CAPABILITY" {
+		c.gotStatusCaps(status.Arguments)
+	}
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/client/cmd_selected.go
+++ b/vendor/github.com/emersion/go-imap/client/cmd_selected.go
@@ -0,0 +1,367 @@
+package client
+
+import (
+	"errors"
+
+	"github.com/emersion/go-imap"
+	"github.com/emersion/go-imap/commands"
+	"github.com/emersion/go-imap/responses"
+)
+
+var (
+	// ErrNoMailboxSelected is returned if a command that requires a mailbox to be
+	// selected is called when there isn't.
+	ErrNoMailboxSelected = errors.New("No mailbox selected")
+
+	// ErrExtensionUnsupported is returned if a command uses a extension that
+	// is not supported by the server.
+	ErrExtensionUnsupported = errors.New("The required extension is not supported by the server")
+)
+
+// Check requests a checkpoint of the currently selected mailbox. A checkpoint
+// refers to any implementation-dependent housekeeping associated with the
+// mailbox that is not normally executed as part of each command.
+func (c *Client) Check() error {
+	if c.State() != imap.SelectedState {
+		return ErrNoMailboxSelected
+	}
+
+	cmd := new(commands.Check)
+
+	status, err := c.execute(cmd, nil)
+	if err != nil {
+		return err
+	}
+
+	return status.Err()
+}
+
+// Close permanently removes all messages that have the \Deleted flag set from
+// the currently selected mailbox, and returns to the authenticated state from
+// the selected state.
+func (c *Client) Close() error {
+	if c.State() != imap.SelectedState {
+		return ErrNoMailboxSelected
+	}
+
+	cmd := new(commands.Close)
+
+	status, err := c.execute(cmd, nil)
+	if err != nil {
+		return err
+	} else if err := status.Err(); err != nil {
+		return err
+	}
+
+	c.locker.Lock()
+	c.state = imap.AuthenticatedState
+	c.mailbox = nil
+	c.locker.Unlock()
+	return nil
+}
+
+// Terminate closes the tcp connection
+func (c *Client) Terminate() error {
+	return c.conn.Close()
+}
+
+// Expunge permanently removes all messages that have the \Deleted flag set from
+// the currently selected mailbox. If ch is not nil, sends sequence IDs of each
+// deleted message to this channel.
+func (c *Client) Expunge(ch chan uint32) error {
+	if ch != nil {
+		defer close(ch)
+	}
+
+	if c.State() != imap.SelectedState {
+		return ErrNoMailboxSelected
+	}
+
+	cmd := new(commands.Expunge)
+
+	var h responses.Handler
+	if ch != nil {
+		h = &responses.Expunge{SeqNums: ch}
+	}
+
+	status, err := c.execute(cmd, h)
+	if err != nil {
+		return err
+	}
+	return status.Err()
+}
+
+func (c *Client) executeSearch(uid bool, criteria *imap.SearchCriteria, charset string) (ids []uint32, status *imap.StatusResp, err error) {
+	if c.State() != imap.SelectedState {
+		err = ErrNoMailboxSelected
+		return
+	}
+
+	var cmd imap.Commander = &commands.Search{
+		Charset:  charset,
+		Criteria: criteria,
+	}
+	if uid {
+		cmd = &commands.Uid{Cmd: cmd}
+	}
+
+	res := new(responses.Search)
+
+	status, err = c.execute(cmd, res)
+	if err != nil {
+		return
+	}
+
+	err, ids = status.Err(), res.Ids
+	return
+}
+
+func (c *Client) search(uid bool, criteria *imap.SearchCriteria) (ids []uint32, err error) {
+	ids, status, err := c.executeSearch(uid, criteria, "UTF-8")
+	if status != nil && status.Code == imap.CodeBadCharset {
+		// Some servers don't support UTF-8
+		ids, _, err = c.executeSearch(uid, criteria, "US-ASCII")
+	}
+	return
+}
+
+// Search searches the mailbox for messages that match the given searching
+// criteria. Searching criteria consist of one or more search keys. The response
+// contains a list of message sequence IDs corresponding to those messages that
+// match the searching criteria. When multiple keys are specified, the result is
+// the intersection (AND function) of all the messages that match those keys.
+// Criteria must be UTF-8 encoded. See RFC 3501 section 6.4.4 for a list of
+// searching criteria. When no criteria has been set, all messages in the mailbox
+// will be searched using ALL criteria.
+func (c *Client) Search(criteria *imap.SearchCriteria) (seqNums []uint32, err error) {
+	return c.search(false, criteria)
+}
+
+// UidSearch is identical to Search, but UIDs are returned instead of message
+// sequence numbers.
+func (c *Client) UidSearch(criteria *imap.SearchCriteria) (uids []uint32, err error) {
+	return c.search(true, criteria)
+}
+
+func (c *Client) fetch(uid bool, seqset *imap.SeqSet, items []imap.FetchItem, ch chan *imap.Message) error {
+	defer close(ch)
+
+	if c.State() != imap.SelectedState {
+		return ErrNoMailboxSelected
+	}
+
+	var cmd imap.Commander = &commands.Fetch{
+		SeqSet: seqset,
+		Items:  items,
+	}
+	if uid {
+		cmd = &commands.Uid{Cmd: cmd}
+	}
+
+	res := &responses.Fetch{Messages: ch, SeqSet: seqset, Uid: uid}
+
+	status, err := c.execute(cmd, res)
+	if err != nil {
+		return err
+	}
+	return status.Err()
+}
+
+// Fetch retrieves data associated with a message in the mailbox. See RFC 3501
+// section 6.4.5 for a list of items that can be requested.
+func (c *Client) Fetch(seqset *imap.SeqSet, items []imap.FetchItem, ch chan *imap.Message) error {
+	return c.fetch(false, seqset, items, ch)
+}
+
+// UidFetch is identical to Fetch, but seqset is interpreted as containing
+// unique identifiers instead of message sequence numbers.
+func (c *Client) UidFetch(seqset *imap.SeqSet, items []imap.FetchItem, ch chan *imap.Message) error {
+	return c.fetch(true, seqset, items, ch)
+}
+
+func (c *Client) store(uid bool, seqset *imap.SeqSet, item imap.StoreItem, value interface{}, ch chan *imap.Message) error {
+	if ch != nil {
+		defer close(ch)
+	}
+
+	if c.State() != imap.SelectedState {
+		return ErrNoMailboxSelected
+	}
+
+	// TODO: this could break extensions (this only works when item is FLAGS)
+	if fields, ok := value.([]interface{}); ok {
+		for i, field := range fields {
+			if s, ok := field.(string); ok {
+				fields[i] = imap.RawString(s)
+			}
+		}
+	}
+
+	// If ch is nil, the updated values are data which will be lost, so don't
+	// retrieve it.
+	if ch == nil {
+		op, _, err := imap.ParseFlagsOp(item)
+		if err == nil {
+			item = imap.FormatFlagsOp(op, true)
+		}
+	}
+
+	var cmd imap.Commander = &commands.Store{
+		SeqSet: seqset,
+		Item:   item,
+		Value:  value,
+	}
+	if uid {
+		cmd = &commands.Uid{Cmd: cmd}
+	}
+
+	var h responses.Handler
+	if ch != nil {
+		h = &responses.Fetch{Messages: ch, SeqSet: seqset, Uid: uid}
+	}
+
+	status, err := c.execute(cmd, h)
+	if err != nil {
+		return err
+	}
+	return status.Err()
+}
+
+// Store alters data associated with a message in the mailbox. If ch is not nil,
+// the updated value of the data will be sent to this channel. See RFC 3501
+// section 6.4.6 for a list of items that can be updated.
+func (c *Client) Store(seqset *imap.SeqSet, item imap.StoreItem, value interface{}, ch chan *imap.Message) error {
+	return c.store(false, seqset, item, value, ch)
+}
+
+// UidStore is identical to Store, but seqset is interpreted as containing
+// unique identifiers instead of message sequence numbers.
+func (c *Client) UidStore(seqset *imap.SeqSet, item imap.StoreItem, value interface{}, ch chan *imap.Message) error {
+	return c.store(true, seqset, item, value, ch)
+}
+
+func (c *Client) copy(uid bool, seqset *imap.SeqSet, dest string) error {
+	if c.State() != imap.SelectedState {
+		return ErrNoMailboxSelected
+	}
+
+	var cmd imap.Commander = &commands.Copy{
+		SeqSet:  seqset,
+		Mailbox: dest,
+	}
+	if uid {
+		cmd = &commands.Uid{Cmd: cmd}
+	}
+
+	status, err := c.execute(cmd, nil)
+	if err != nil {
+		return err
+	}
+	return status.Err()
+}
+
+// Copy copies the specified message(s) to the end of the specified destination
+// mailbox.
+func (c *Client) Copy(seqset *imap.SeqSet, dest string) error {
+	return c.copy(false, seqset, dest)
+}
+
+// UidCopy is identical to Copy, but seqset is interpreted as containing unique
+// identifiers instead of message sequence numbers.
+func (c *Client) UidCopy(seqset *imap.SeqSet, dest string) error {
+	return c.copy(true, seqset, dest)
+}
+
+func (c *Client) move(uid bool, seqset *imap.SeqSet, dest string) error {
+	if c.State() != imap.SelectedState {
+		return ErrNoMailboxSelected
+	}
+
+	if ok, err := c.Support("MOVE"); err != nil {
+		return err
+	} else if !ok {
+		return c.moveFallback(uid, seqset, dest)
+	}
+
+	var cmd imap.Commander = &commands.Move{
+		SeqSet:  seqset,
+		Mailbox: dest,
+	}
+	if uid {
+		cmd = &commands.Uid{Cmd: cmd}
+	}
+
+	if status, err := c.Execute(cmd, nil); err != nil {
+		return err
+	} else {
+		return status.Err()
+	}
+}
+
+// moveFallback uses COPY, STORE and EXPUNGE for servers which don't support
+// MOVE.
+func (c *Client) moveFallback(uid bool, seqset *imap.SeqSet, dest string) error {
+	item := imap.FormatFlagsOp(imap.AddFlags, true)
+	flags := []interface{}{imap.DeletedFlag}
+	if uid {
+		if err := c.UidCopy(seqset, dest); err != nil {
+			return err
+		}
+
+		if err := c.UidStore(seqset, item, flags, nil); err != nil {
+			return err
+		}
+	} else {
+		if err := c.Copy(seqset, dest); err != nil {
+			return err
+		}
+
+		if err := c.Store(seqset, item, flags, nil); err != nil {
+			return err
+		}
+	}
+
+	return c.Expunge(nil)
+}
+
+// Move moves the specified message(s) to the end of the specified destination
+// mailbox.
+//
+// If the server doesn't support the MOVE extension defined in RFC 6851,
+// go-imap will fallback to copy, store and expunge.
+func (c *Client) Move(seqset *imap.SeqSet, dest string) error {
+	return c.move(false, seqset, dest)
+}
+
+// UidMove is identical to Move, but seqset is interpreted as containing unique
+// identifiers instead of message sequence numbers.
+func (c *Client) UidMove(seqset *imap.SeqSet, dest string) error {
+	return c.move(true, seqset, dest)
+}
+
+// Unselect frees server's resources associated with the selected mailbox and
+// returns the server to the authenticated state. This command performs the same
+// actions as Close, except that no messages are permanently removed from the
+// currently selected mailbox.
+//
+// If client does not support the UNSELECT extension, ErrExtensionUnsupported
+// is returned.
+func (c *Client) Unselect() error {
+	if ok, err := c.Support("UNSELECT"); !ok || err != nil {
+		return ErrExtensionUnsupported
+	}
+
+	if c.State() != imap.SelectedState {
+		return ErrNoMailboxSelected
+	}
+
+	cmd := &commands.Unselect{}
+	if status, err := c.Execute(cmd, nil); err != nil {
+		return err
+	} else if err := status.Err(); err != nil {
+		return err
+	}
+
+	c.SetState(imap.AuthenticatedState, nil)
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/client/tag.go
+++ b/vendor/github.com/emersion/go-imap/client/tag.go
@@ -0,0 +1,24 @@
+package client
+
+import (
+	"crypto/rand"
+	"encoding/base64"
+)
+
+func randomString(n int) (string, error) {
+	b := make([]byte, n)
+	_, err := rand.Read(b)
+	if err != nil {
+		return "", err
+	}
+
+	return base64.RawURLEncoding.EncodeToString(b), nil
+}
+
+func generateTag() string {
+	tag, err := randomString(4)
+	if err != nil {
+		panic(err)
+	}
+	return tag
+}
--- a/vendor/github.com/emersion/go-imap/command.go
+++ b/vendor/github.com/emersion/go-imap/command.go
@@ -0,0 +1,57 @@
+package imap
+
+import (
+	"errors"
+	"strings"
+)
+
+// A value that can be converted to a command.
+type Commander interface {
+	Command() *Command
+}
+
+// A command.
+type Command struct {
+	// The command tag. It acts as a unique identifier for this command. If empty,
+	// the command is untagged.
+	Tag string
+	// The command name.
+	Name string
+	// The command arguments.
+	Arguments []interface{}
+}
+
+// Implements the Commander interface.
+func (cmd *Command) Command() *Command {
+	return cmd
+}
+
+func (cmd *Command) WriteTo(w *Writer) error {
+	tag := cmd.Tag
+	if tag == "" {
+		tag = "*"
+	}
+
+	fields := []interface{}{RawString(tag), RawString(cmd.Name)}
+	fields = append(fields, cmd.Arguments...)
+	return w.writeLine(fields...)
+}
+
+// Parse a command from fields.
+func (cmd *Command) Parse(fields []interface{}) error {
+	if len(fields) < 2 {
+		return errors.New("imap: cannot parse command: no enough fields")
+	}
+
+	var ok bool
+	if cmd.Tag, ok = fields[0].(string); !ok {
+		return errors.New("imap: cannot parse command: invalid tag")
+	}
+	if cmd.Name, ok = fields[1].(string); !ok {
+		return errors.New("imap: cannot parse command: invalid name")
+	}
+	cmd.Name = strings.ToUpper(cmd.Name) // Command names are case-insensitive
+
+	cmd.Arguments = fields[2:]
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/commands/append.go
+++ b/vendor/github.com/emersion/go-imap/commands/append.go
@@ -0,0 +1,93 @@
+package commands
+
+import (
+	"errors"
+	"time"
+
+	"github.com/emersion/go-imap"
+	"github.com/emersion/go-imap/utf7"
+)
+
+// Append is an APPEND command, as defined in RFC 3501 section 6.3.11.
+type Append struct {
+	Mailbox string
+	Flags   []string
+	Date    time.Time
+	Message imap.Literal
+}
+
+func (cmd *Append) Command() *imap.Command {
+	var args []interface{}
+
+	mailbox, _ := utf7.Encoding.NewEncoder().String(cmd.Mailbox)
+	args = append(args, imap.FormatMailboxName(mailbox))
+
+	if cmd.Flags != nil {
+		flags := make([]interface{}, len(cmd.Flags))
+		for i, flag := range cmd.Flags {
+			flags[i] = imap.RawString(flag)
+		}
+		args = append(args, flags)
+	}
+
+	if !cmd.Date.IsZero() {
+		args = append(args, cmd.Date)
+	}
+
+	args = append(args, cmd.Message)
+
+	return &imap.Command{
+		Name:      "APPEND",
+		Arguments: args,
+	}
+}
+
+func (cmd *Append) Parse(fields []interface{}) (err error) {
+	if len(fields) < 2 {
+		return errors.New("No enough arguments")
+	}
+
+	// Parse mailbox name
+	if mailbox, err := imap.ParseString(fields[0]); err != nil {
+		return err
+	} else if mailbox, err = utf7.Encoding.NewDecoder().String(mailbox); err != nil {
+		return err
+	} else {
+		cmd.Mailbox = imap.CanonicalMailboxName(mailbox)
+	}
+
+	// Parse message literal
+	litIndex := len(fields) - 1
+	var ok bool
+	if cmd.Message, ok = fields[litIndex].(imap.Literal); !ok {
+		return errors.New("Message must be a literal")
+	}
+
+	// Remaining fields a optional
+	fields = fields[1:litIndex]
+	if len(fields) > 0 {
+		// Parse flags list
+		if flags, ok := fields[0].([]interface{}); ok {
+			if cmd.Flags, err = imap.ParseStringList(flags); err != nil {
+				return err
+			}
+
+			for i, flag := range cmd.Flags {
+				cmd.Flags[i] = imap.CanonicalFlag(flag)
+			}
+
+			fields = fields[1:]
+		}
+
+		// Parse date
+		if len(fields) > 0 {
+			if date, ok := fields[0].(string); !ok {
+				return errors.New("Date must be a string")
+			} else if cmd.Date, err = time.Parse(imap.DateTimeLayout, date); err != nil {
+				return err
+			}
+		}
+	}
+
+	return
+}
--- a/vendor/github.com/emersion/go-imap/commands/authenticate.go
+++ b/vendor/github.com/emersion/go-imap/commands/authenticate.go
@@ -0,0 +1,124 @@
+package commands
+
+import (
+	"bufio"
+	"encoding/base64"
+	"errors"
+	"io"
+	"strings"
+
+	"github.com/emersion/go-imap"
+	"github.com/emersion/go-sasl"
+)
+
+// AuthenticateConn is a connection that supports IMAP authentication.
+type AuthenticateConn interface {
+	io.Reader
+
+	// WriteResp writes an IMAP response to this connection.
+	WriteResp(res imap.WriterTo) error
+}
+
+// Authenticate is an AUTHENTICATE command, as defined in RFC 3501 section
+// 6.2.2.
+type Authenticate struct {
+	Mechanism       string
+	InitialResponse []byte
+}
+
+func (cmd *Authenticate) Command() *imap.Command {
+	args := []interface{}{imap.RawString(cmd.Mechanism)}
+	if cmd.InitialResponse != nil {
+		var encodedResponse string
+		if len(cmd.InitialResponse) == 0 {
+			// Empty initial response should be encoded as "=", not empty
+			// string.
+			encodedResponse = "="
+		} else {
+			encodedResponse = base64.StdEncoding.EncodeToString(cmd.InitialResponse)
+		}
+
+		args = append(args, imap.RawString(encodedResponse))
+	}
+	return &imap.Command{
+		Name:      "AUTHENTICATE",
+		Arguments: args,
+	}
+}
+
+func (cmd *Authenticate) Parse(fields []interface{}) error {
+	if len(fields) < 1 {
+		return errors.New("Not enough arguments")
+	}
+
+	var ok bool
+	if cmd.Mechanism, ok = fields[0].(string); !ok {
+		return errors.New("Mechanism must be a string")
+	}
+	cmd.Mechanism = strings.ToUpper(cmd.Mechanism)
+
+	if len(fields) != 2 {
+		return nil
+	}
+
+	encodedResponse, ok := fields[1].(string)
+	if !ok {
+		return errors.New("Initial response must be a string")
+	}
+	if encodedResponse == "=" {
+		cmd.InitialResponse = []byte{}
+		return nil
+	}
+
+	var err error
+	cmd.InitialResponse, err = base64.StdEncoding.DecodeString(encodedResponse)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (cmd *Authenticate) Handle(mechanisms map[string]sasl.Server, conn AuthenticateConn) error {
+	sasl, ok := mechanisms[cmd.Mechanism]
+	if !ok {
+		return errors.New("Unsupported mechanism")
+	}
+
+	scanner := bufio.NewScanner(conn)
+
+	response := cmd.InitialResponse
+	for {
+		challenge, done, err := sasl.Next(response)
+		if err != nil || done {
+			return err
+		}
+
+		encoded := base64.StdEncoding.EncodeToString(challenge)
+		cont := &imap.ContinuationReq{Info: encoded}
+		if err := conn.WriteResp(cont); err != nil {
+			return err
+		}
+
+		if !scanner.Scan() {
+			if err := scanner.Err(); err != nil {
+				return err
+			}
+			return errors.New("unexpected EOF")
+		}
+
+		encoded = scanner.Text()
+		if encoded != "" {
+			if encoded == "*" {
+				return &imap.ErrStatusResp{Resp: &imap.StatusResp{
+					Type: imap.StatusRespBad,
+					Info: "negotiation cancelled",
+				}}
+			}
+			response, err = base64.StdEncoding.DecodeString(encoded)
+			if err != nil {
+				return err
+			}
+		}
+	}
+}
--- a/vendor/github.com/emersion/go-imap/commands/capability.go
+++ b/vendor/github.com/emersion/go-imap/commands/capability.go
@@ -0,0 +1,18 @@
+package commands
+
+import (
+	"github.com/emersion/go-imap"
+)
+
+// Capability is a CAPABILITY command, as defined in RFC 3501 section 6.1.1.
+type Capability struct{}
+
+func (c *Capability) Command() *imap.Command {
+	return &imap.Command{
+		Name: "CAPABILITY",
+	}
+}
+
+func (c *Capability) Parse(fields []interface{}) error {
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/commands/check.go
+++ b/vendor/github.com/emersion/go-imap/commands/check.go
@@ -0,0 +1,18 @@
+package commands
+
+import (
+	"github.com/emersion/go-imap"
+)
+
+// Check is a CHECK command, as defined in RFC 3501 section 6.4.1.
+type Check struct{}
+
+func (cmd *Check) Command() *imap.Command {
+	return &imap.Command{
+		Name: "CHECK",
+	}
+}
+
+func (cmd *Check) Parse(fields []interface{}) error {
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/commands/close.go
+++ b/vendor/github.com/emersion/go-imap/commands/close.go
@@ -0,0 +1,18 @@
+package commands
+
+import (
+	"github.com/emersion/go-imap"
+)
+
+// Close is a CLOSE command, as defined in RFC 3501 section 6.4.2.
+type Close struct{}
+
+func (cmd *Close) Command() *imap.Command {
+	return &imap.Command{
+		Name: "CLOSE",
+	}
+}
+
+func (cmd *Close) Parse(fields []interface{}) error {
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/commands/commands.go
+++ b/vendor/github.com/emersion/go-imap/commands/commands.go
@@ -0,0 +1,2 @@
+// Package commands implements IMAP commands defined in RFC 3501.
+package commands
--- a/vendor/github.com/emersion/go-imap/commands/copy.go
+++ b/vendor/github.com/emersion/go-imap/commands/copy.go
@@ -0,0 +1,47 @@
+package commands
+
+import (
+	"errors"
+
+	"github.com/emersion/go-imap"
+	"github.com/emersion/go-imap/utf7"
+)
+
+// Copy is a COPY command, as defined in RFC 3501 section 6.4.7.
+type Copy struct {
+	SeqSet  *imap.SeqSet
+	Mailbox string
+}
+
+func (cmd *Copy) Command() *imap.Command {
+	mailbox, _ := utf7.Encoding.NewEncoder().String(cmd.Mailbox)
+
+	return &imap.Command{
+		Name:      "COPY",
+		Arguments: []interface{}{cmd.SeqSet, imap.FormatMailboxName(mailbox)},
+	}
+}
+
+func (cmd *Copy) Parse(fields []interface{}) error {
+	if len(fields) < 2 {
+		return errors.New("No enough arguments")
+	}
+
+	if seqSet, ok := fields[0].(string); !ok {
+		return errors.New("Invalid sequence set")
+	} else if seqSet, err := imap.ParseSeqSet(seqSet); err != nil {
+		return err
+	} else {
+		cmd.SeqSet = seqSet
+	}
+
+	if mailbox, err := imap.ParseString(fields[1]); err != nil {
+		return err
+	} else if mailbox, err := utf7.Encoding.NewDecoder().String(mailbox); err != nil {
+		return err
+	} else {
+		cmd.Mailbox = imap.CanonicalMailboxName(mailbox)
+	}
+
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/commands/create.go
+++ b/vendor/github.com/emersion/go-imap/commands/create.go
@@ -0,0 +1,38 @@
+package commands
+
+import (
+	"errors"
+
+	"github.com/emersion/go-imap"
+	"github.com/emersion/go-imap/utf7"
+)
+
+// Create is a CREATE command, as defined in RFC 3501 section 6.3.3.
+type Create struct {
+	Mailbox string
+}
+
+func (cmd *Create) Command() *imap.Command {
+	mailbox, _ := utf7.Encoding.NewEncoder().String(cmd.Mailbox)
+
+	return &imap.Command{
+		Name:      "CREATE",
+		Arguments: []interface{}{mailbox},
+	}
+}
+
+func (cmd *Create) Parse(fields []interface{}) error {
+	if len(fields) < 1 {
+		return errors.New("No enough arguments")
+	}
+
+	if mailbox, err := imap.ParseString(fields[0]); err != nil {
+		return err
+	} else if mailbox, err := utf7.Encoding.NewDecoder().String(mailbox); err != nil {
+		return err
+	} else {
+		cmd.Mailbox = imap.CanonicalMailboxName(mailbox)
+	}
+
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/commands/delete.go
+++ b/vendor/github.com/emersion/go-imap/commands/delete.go
@@ -0,0 +1,38 @@
+package commands
+
+import (
+	"errors"
+
+	"github.com/emersion/go-imap"
+	"github.com/emersion/go-imap/utf7"
+)
+
+// Delete is a DELETE command, as defined in RFC 3501 section 6.3.3.
+type Delete struct {
+	Mailbox string
+}
+
+func (cmd *Delete) Command() *imap.Command {
+	mailbox, _ := utf7.Encoding.NewEncoder().String(cmd.Mailbox)
+
+	return &imap.Command{
+		Name:      "DELETE",
+		Arguments: []interface{}{imap.FormatMailboxName(mailbox)},
+	}
+}
+
+func (cmd *Delete) Parse(fields []interface{}) error {
+	if len(fields) < 1 {
+		return errors.New("No enough arguments")
+	}
+
+	if mailbox, err := imap.ParseString(fields[0]); err != nil {
+		return err
+	} else if mailbox, err := utf7.Encoding.NewDecoder().String(mailbox); err != nil {
+		return err
+	} else {
+		cmd.Mailbox = imap.CanonicalMailboxName(mailbox)
+	}
+
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/commands/enable.go
+++ b/vendor/github.com/emersion/go-imap/commands/enable.go
@@ -0,0 +1,23 @@
+package commands
+
+import (
+	"github.com/emersion/go-imap"
+)
+
+// An ENABLE command, defined in RFC 5161 section 3.1.
+type Enable struct {
+	Caps []string
+}
+
+func (cmd *Enable) Command() *imap.Command {
+	return &imap.Command{
+		Name:      "ENABLE",
+		Arguments: imap.FormatStringList(cmd.Caps),
+	}
+}
+
+func (cmd *Enable) Parse(fields []interface{}) error {
+	var err error
+	cmd.Caps, err = imap.ParseStringList(fields)
+	return err
+}
--- a/vendor/github.com/emersion/go-imap/commands/expunge.go
+++ b/vendor/github.com/emersion/go-imap/commands/expunge.go
@@ -0,0 +1,16 @@
+package commands
+
+import (
+	"github.com/emersion/go-imap"
+)
+
+// Expunge is an EXPUNGE command, as defined in RFC 3501 section 6.4.3.
+type Expunge struct{}
+
+func (cmd *Expunge) Command() *imap.Command {
+	return &imap.Command{Name: "EXPUNGE"}
+}
+
+func (cmd *Expunge) Parse(fields []interface{}) error {
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/commands/fetch.go
+++ b/vendor/github.com/emersion/go-imap/commands/fetch.go
@@ -0,0 +1,63 @@
+package commands
+
+import (
+	"errors"
+	"strings"
+
+	"github.com/emersion/go-imap"
+)
+
+// Fetch is a FETCH command, as defined in RFC 3501 section 6.4.5.
+type Fetch struct {
+	SeqSet *imap.SeqSet
+	Items  []imap.FetchItem
+}
+
+func (cmd *Fetch) Command() *imap.Command {
+	// Handle FETCH macros separately as they should not be serialized within parentheses
+	if len(cmd.Items) == 1 && (cmd.Items[0] == imap.FetchAll || cmd.Items[0] == imap.FetchFast || cmd.Items[0] == imap.FetchFull) {
+		return &imap.Command{
+			Name:      "FETCH",
+			Arguments: []interface{}{cmd.SeqSet, imap.RawString(cmd.Items[0])},
+		}
+	} else {
+		items := make([]interface{}, len(cmd.Items))
+		for i, item := range cmd.Items {
+			items[i] = imap.RawString(item)
+		}
+
+		return &imap.Command{
+			Name:      "FETCH",
+			Arguments: []interface{}{cmd.SeqSet, items},
+		}
+	}
+}
+
+func (cmd *Fetch) Parse(fields []interface{}) error {
+	if len(fields) < 2 {
+		return errors.New("No enough arguments")
+	}
+
+	var err error
+	if seqset, ok := fields[0].(string); !ok {
+		return errors.New("Sequence set must be an atom")
+	} else if cmd.SeqSet, err = imap.ParseSeqSet(seqset); err != nil {
+		return err
+	}
+
+	switch items := fields[1].(type) {
+	case string: // A macro or a single item
+		cmd.Items = imap.FetchItem(strings.ToUpper(items)).Expand()
+	case []interface{}: // A list of items
+		cmd.Items = make([]imap.FetchItem, 0, len(items))
+		for _, v := range items {
+			itemStr, _ := v.(string)
+			item := imap.FetchItem(strings.ToUpper(itemStr))
+			cmd.Items = append(cmd.Items, item.Expand()...)
+		}
+	default:
+		return errors.New("Items must be either a string or a list")
+	}
+
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/commands/idle.go
+++ b/vendor/github.com/emersion/go-imap/commands/idle.go
@@ -0,0 +1,17 @@
+package commands
+
+import (
+	"github.com/emersion/go-imap"
+)
+
+// An IDLE command.
+// Se RFC 2177 section 3.
+type Idle struct{}
+
+func (cmd *Idle) Command() *imap.Command {
+	return &imap.Command{Name: "IDLE"}
+}
+
+func (cmd *Idle) Parse(fields []interface{}) error {
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/commands/list.go
+++ b/vendor/github.com/emersion/go-imap/commands/list.go
@@ -0,0 +1,60 @@
+package commands
+
+import (
+	"errors"
+
+	"github.com/emersion/go-imap"
+	"github.com/emersion/go-imap/utf7"
+)
+
+// List is a LIST command, as defined in RFC 3501 section 6.3.8. If Subscribed
+// is set to true, LSUB will be used instead.
+type List struct {
+	Reference string
+	Mailbox   string
+
+	Subscribed bool
+}
+
+func (cmd *List) Command() *imap.Command {
+	name := "LIST"
+	if cmd.Subscribed {
+		name = "LSUB"
+	}
+
+	enc := utf7.Encoding.NewEncoder()
+	ref, _ := enc.String(cmd.Reference)
+	mailbox, _ := enc.String(cmd.Mailbox)
+
+	return &imap.Command{
+		Name:      name,
+		Arguments: []interface{}{ref, mailbox},
+	}
+}
+
+func (cmd *List) Parse(fields []interface{}) error {
+	if len(fields) < 2 {
+		return errors.New("No enough arguments")
+	}
+
+	dec := utf7.Encoding.NewDecoder()
+
+	if mailbox, err := imap.ParseString(fields[0]); err != nil {
+		return err
+	} else if mailbox, err := dec.String(mailbox); err != nil {
+		return err
+	} else {
+		// TODO: canonical mailbox path
+		cmd.Reference = imap.CanonicalMailboxName(mailbox)
+	}
+
+	if mailbox, err := imap.ParseString(fields[1]); err != nil {
+		return err
+	} else if mailbox, err := dec.String(mailbox); err != nil {
+		return err
+	} else {
+		cmd.Mailbox = imap.CanonicalMailboxName(mailbox)
+	}
+
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/commands/login.go
+++ b/vendor/github.com/emersion/go-imap/commands/login.go
@@ -0,0 +1,36 @@
+package commands
+
+import (
+	"errors"
+
+	"github.com/emersion/go-imap"
+)
+
+// Login is a LOGIN command, as defined in RFC 3501 section 6.2.2.
+type Login struct {
+	Username string
+	Password string
+}
+
+func (cmd *Login) Command() *imap.Command {
+	return &imap.Command{
+		Name:      "LOGIN",
+		Arguments: []interface{}{cmd.Username, cmd.Password},
+	}
+}
+
+func (cmd *Login) Parse(fields []interface{}) error {
+	if len(fields) < 2 {
+		return errors.New("Not enough arguments")
+	}
+
+	var err error
+	if cmd.Username, err = imap.ParseString(fields[0]); err != nil {
+		return err
+	}
+	if cmd.Password, err = imap.ParseString(fields[1]); err != nil {
+		return err
+	}
+
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/commands/logout.go
+++ b/vendor/github.com/emersion/go-imap/commands/logout.go
@@ -0,0 +1,18 @@
+package commands
+
+import (
+	"github.com/emersion/go-imap"
+)
+
+// Logout is a LOGOUT command, as defined in RFC 3501 section 6.1.3.
+type Logout struct{}
+
+func (c *Logout) Command() *imap.Command {
+	return &imap.Command{
+		Name: "LOGOUT",
+	}
+}
+
+func (c *Logout) Parse(fields []interface{}) error {
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/commands/move.go
+++ b/vendor/github.com/emersion/go-imap/commands/move.go
@@ -0,0 +1,48 @@
+package commands
+
+import (
+	"errors"
+
+	"github.com/emersion/go-imap"
+	"github.com/emersion/go-imap/utf7"
+)
+
+// A MOVE command.
+// See RFC 6851 section 3.1.
+type Move struct {
+	SeqSet  *imap.SeqSet
+	Mailbox string
+}
+
+func (cmd *Move) Command() *imap.Command {
+	mailbox, _ := utf7.Encoding.NewEncoder().String(cmd.Mailbox)
+
+	return &imap.Command{
+		Name:      "MOVE",
+		Arguments: []interface{}{cmd.SeqSet, mailbox},
+	}
+}
+
+func (cmd *Move) Parse(fields []interface{}) (err error) {
+	if len(fields) < 2 {
+		return errors.New("No enough arguments")
+	}
+
+	seqset, ok := fields[0].(string)
+	if !ok {
+		return errors.New("Invalid sequence set")
+	}
+	if cmd.SeqSet, err = imap.ParseSeqSet(seqset); err != nil {
+		return err
+	}
+
+	mailbox, ok := fields[1].(string)
+	if !ok {
+		return errors.New("Mailbox name must be a string")
+	}
+	if cmd.Mailbox, err = utf7.Encoding.NewDecoder().String(mailbox); err != nil {
+		return err
+	}
+
+	return
+}
--- a/vendor/github.com/emersion/go-imap/commands/noop.go
+++ b/vendor/github.com/emersion/go-imap/commands/noop.go
@@ -0,0 +1,18 @@
+package commands
+
+import (
+	"github.com/emersion/go-imap"
+)
+
+// Noop is a NOOP command, as defined in RFC 3501 section 6.1.2.
+type Noop struct{}
+
+func (c *Noop) Command() *imap.Command {
+	return &imap.Command{
+		Name: "NOOP",
+	}
+}
+
+func (c *Noop) Parse(fields []interface{}) error {
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/commands/rename.go
+++ b/vendor/github.com/emersion/go-imap/commands/rename.go
@@ -0,0 +1,51 @@
+package commands
+
+import (
+	"errors"
+
+	"github.com/emersion/go-imap"
+	"github.com/emersion/go-imap/utf7"
+)
+
+// Rename is a RENAME command, as defined in RFC 3501 section 6.3.5.
+type Rename struct {
+	Existing string
+	New      string
+}
+
+func (cmd *Rename) Command() *imap.Command {
+	enc := utf7.Encoding.NewEncoder()
+	existingName, _ := enc.String(cmd.Existing)
+	newName, _ := enc.String(cmd.New)
+
+	return &imap.Command{
+		Name:      "RENAME",
+		Arguments: []interface{}{imap.FormatMailboxName(existingName), imap.FormatMailboxName(newName)},
+	}
+}
+
+func (cmd *Rename) Parse(fields []interface{}) error {
+	if len(fields) < 2 {
+		return errors.New("No enough arguments")
+	}
+
+	dec := utf7.Encoding.NewDecoder()
+
+	if existingName, err := imap.ParseString(fields[0]); err != nil {
+		return err
+	} else if existingName, err := dec.String(existingName); err != nil {
+		return err
+	} else {
+		cmd.Existing = imap.CanonicalMailboxName(existingName)
+	}
+
+	if newName, err := imap.ParseString(fields[1]); err != nil {
+		return err
+	} else if newName, err := dec.String(newName); err != nil {
+		return err
+	} else {
+		cmd.New = imap.CanonicalMailboxName(newName)
+	}
+
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/commands/search.go
+++ b/vendor/github.com/emersion/go-imap/commands/search.go
@@ -0,0 +1,57 @@
+package commands
+
+import (
+	"errors"
+	"io"
+	"strings"
+
+	"github.com/emersion/go-imap"
+)
+
+// Search is a SEARCH command, as defined in RFC 3501 section 6.4.4.
+type Search struct {
+	Charset  string
+	Criteria *imap.SearchCriteria
+}
+
+func (cmd *Search) Command() *imap.Command {
+	var args []interface{}
+	if cmd.Charset != "" {
+		args = append(args, imap.RawString("CHARSET"), imap.RawString(cmd.Charset))
+	}
+	args = append(args, cmd.Criteria.Format()...)
+
+	return &imap.Command{
+		Name:      "SEARCH",
+		Arguments: args,
+	}
+}
+
+func (cmd *Search) Parse(fields []interface{}) error {
+	if len(fields) == 0 {
+		return errors.New("Missing search criteria")
+	}
+
+	// Parse charset
+	if f, ok := fields[0].(string); ok && strings.EqualFold(f, "CHARSET") {
+		if len(fields) < 2 {
+			return errors.New("Missing CHARSET value")
+		}
+		if cmd.Charset, ok = fields[1].(string); !ok {
+			return errors.New("Charset must be a string")
+		}
+		fields = fields[2:]
+	}
+
+	var charsetReader func(io.Reader) io.Reader
+	charset := strings.ToLower(cmd.Charset)
+	if charset != "utf-8" && charset != "us-ascii" && charset != "" {
+		charsetReader = func(r io.Reader) io.Reader {
+			r, _ = imap.CharsetReader(charset, r)
+			return r
+		}
+	}
+
+	cmd.Criteria = new(imap.SearchCriteria)
+	return cmd.Criteria.ParseWithCharset(fields, charsetReader)
+}
--- a/vendor/github.com/emersion/go-imap/commands/select.go
+++ b/vendor/github.com/emersion/go-imap/commands/select.go
@@ -0,0 +1,45 @@
+package commands
+
+import (
+	"errors"
+
+	"github.com/emersion/go-imap"
+	"github.com/emersion/go-imap/utf7"
+)
+
+// Select is a SELECT command, as defined in RFC 3501 section 6.3.1. If ReadOnly
+// is set to true, the EXAMINE command will be used instead.
+type Select struct {
+	Mailbox  string
+	ReadOnly bool
+}
+
+func (cmd *Select) Command() *imap.Command {
+	name := "SELECT"
+	if cmd.ReadOnly {
+		name = "EXAMINE"
+	}
+
+	mailbox, _ := utf7.Encoding.NewEncoder().String(cmd.Mailbox)
+
+	return &imap.Command{
+		Name:      name,
+		Arguments: []interface{}{imap.FormatMailboxName(mailbox)},
+	}
+}
+
+func (cmd *Select) Parse(fields []interface{}) error {
+	if len(fields) < 1 {
+		return errors.New("No enough arguments")
+	}
+
+	if mailbox, err := imap.ParseString(fields[0]); err != nil {
+		return err
+	} else if mailbox, err := utf7.Encoding.NewDecoder().String(mailbox); err != nil {
+		return err
+	} else {
+		cmd.Mailbox = imap.CanonicalMailboxName(mailbox)
+	}
+
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/commands/starttls.go
+++ b/vendor/github.com/emersion/go-imap/commands/starttls.go
@@ -0,0 +1,18 @@
+package commands
+
+import (
+	"github.com/emersion/go-imap"
+)
+
+// StartTLS is a STARTTLS command, as defined in RFC 3501 section 6.2.1.
+type StartTLS struct{}
+
+func (cmd *StartTLS) Command() *imap.Command {
+	return &imap.Command{
+		Name: "STARTTLS",
+	}
+}
+
+func (cmd *StartTLS) Parse(fields []interface{}) error {
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/commands/status.go
+++ b/vendor/github.com/emersion/go-imap/commands/status.go
@@ -0,0 +1,58 @@
+package commands
+
+import (
+	"errors"
+	"strings"
+
+	"github.com/emersion/go-imap"
+	"github.com/emersion/go-imap/utf7"
+)
+
+// Status is a STATUS command, as defined in RFC 3501 section 6.3.10.
+type Status struct {
+	Mailbox string
+	Items   []imap.StatusItem
+}
+
+func (cmd *Status) Command() *imap.Command {
+	mailbox, _ := utf7.Encoding.NewEncoder().String(cmd.Mailbox)
+
+	items := make([]interface{}, len(cmd.Items))
+	for i, item := range cmd.Items {
+		items[i] = imap.RawString(item)
+	}
+
+	return &imap.Command{
+		Name:      "STATUS",
+		Arguments: []interface{}{imap.FormatMailboxName(mailbox), items},
+	}
+}
+
+func (cmd *Status) Parse(fields []interface{}) error {
+	if len(fields) < 2 {
+		return errors.New("No enough arguments")
+	}
+
+	if mailbox, err := imap.ParseString(fields[0]); err != nil {
+		return err
+	} else if mailbox, err := utf7.Encoding.NewDecoder().String(mailbox); err != nil {
+		return err
+	} else {
+		cmd.Mailbox = imap.CanonicalMailboxName(mailbox)
+	}
+
+	items, ok := fields[1].([]interface{})
+	if !ok {
+		return errors.New("STATUS command parameter is not a list")
+	}
+	cmd.Items = make([]imap.StatusItem, len(items))
+	for i, f := range items {
+		if s, ok := f.(string); !ok {
+			return errors.New("Got a non-string field in a STATUS command parameter")
+		} else {
+			cmd.Items[i] = imap.StatusItem(strings.ToUpper(s))
+		}
+	}
+
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/commands/store.go
+++ b/vendor/github.com/emersion/go-imap/commands/store.go
@@ -0,0 +1,50 @@
+package commands
+
+import (
+	"errors"
+	"strings"
+
+	"github.com/emersion/go-imap"
+)
+
+// Store is a STORE command, as defined in RFC 3501 section 6.4.6.
+type Store struct {
+	SeqSet *imap.SeqSet
+	Item   imap.StoreItem
+	Value  interface{}
+}
+
+func (cmd *Store) Command() *imap.Command {
+	return &imap.Command{
+		Name:      "STORE",
+		Arguments: []interface{}{cmd.SeqSet, imap.RawString(cmd.Item), cmd.Value},
+	}
+}
+
+func (cmd *Store) Parse(fields []interface{}) error {
+	if len(fields) < 3 {
+		return errors.New("No enough arguments")
+	}
+
+	seqset, ok := fields[0].(string)
+	if !ok {
+		return errors.New("Invalid sequence set")
+	}
+	var err error
+	if cmd.SeqSet, err = imap.ParseSeqSet(seqset); err != nil {
+		return err
+	}
+
+	if item, ok := fields[1].(string); !ok {
+		return errors.New("Item name must be a string")
+	} else {
+		cmd.Item = imap.StoreItem(strings.ToUpper(item))
+	}
+
+	if len(fields[2:]) == 1 {
+		cmd.Value = fields[2]
+	} else {
+		cmd.Value = fields[2:]
+	}
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/commands/subscribe.go
+++ b/vendor/github.com/emersion/go-imap/commands/subscribe.go
@@ -0,0 +1,63 @@
+package commands
+
+import (
+	"errors"
+
+	"github.com/emersion/go-imap"
+	"github.com/emersion/go-imap/utf7"
+)
+
+// Subscribe is a SUBSCRIBE command, as defined in RFC 3501 section 6.3.6.
+type Subscribe struct {
+	Mailbox string
+}
+
+func (cmd *Subscribe) Command() *imap.Command {
+	mailbox, _ := utf7.Encoding.NewEncoder().String(cmd.Mailbox)
+
+	return &imap.Command{
+		Name:      "SUBSCRIBE",
+		Arguments: []interface{}{imap.FormatMailboxName(mailbox)},
+	}
+}
+
+func (cmd *Subscribe) Parse(fields []interface{}) error {
+	if len(fields) < 0 {
+		return errors.New("No enough arguments")
+	}
+
+	if mailbox, err := imap.ParseString(fields[0]); err != nil {
+		return err
+	} else if cmd.Mailbox, err = utf7.Encoding.NewDecoder().String(mailbox); err != nil {
+		return err
+	}
+	return nil
+}
+
+// An UNSUBSCRIBE command.
+// See RFC 3501 section 6.3.7
+type Unsubscribe struct {
+	Mailbox string
+}
+
+func (cmd *Unsubscribe) Command() *imap.Command {
+	mailbox, _ := utf7.Encoding.NewEncoder().String(cmd.Mailbox)
+
+	return &imap.Command{
+		Name:      "UNSUBSCRIBE",
+		Arguments: []interface{}{imap.FormatMailboxName(mailbox)},
+	}
+}
+
+func (cmd *Unsubscribe) Parse(fields []interface{}) error {
+	if len(fields) < 0 {
+		return errors.New("No enogh arguments")
+	}
+
+	if mailbox, err := imap.ParseString(fields[0]); err != nil {
+		return err
+	} else if cmd.Mailbox, err = utf7.Encoding.NewDecoder().String(mailbox); err != nil {
+		return err
+	}
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/commands/uid.go
+++ b/vendor/github.com/emersion/go-imap/commands/uid.go
@@ -0,0 +1,44 @@
+package commands
+
+import (
+	"errors"
+	"strings"
+
+	"github.com/emersion/go-imap"
+)
+
+// Uid is a UID command, as defined in RFC 3501 section 6.4.8. It wraps another
+// command (e.g. wrapping a Fetch command will result in a UID FETCH).
+type Uid struct {
+	Cmd imap.Commander
+}
+
+func (cmd *Uid) Command() *imap.Command {
+	inner := cmd.Cmd.Command()
+
+	args := []interface{}{imap.RawString(inner.Name)}
+	args = append(args, inner.Arguments...)
+
+	return &imap.Command{
+		Name:      "UID",
+		Arguments: args,
+	}
+}
+
+func (cmd *Uid) Parse(fields []interface{}) error {
+	if len(fields) < 0 {
+		return errors.New("No command name specified")
+	}
+
+	name, ok := fields[0].(string)
+	if !ok {
+		return errors.New("Command name must be a string")
+	}
+
+	cmd.Cmd = &imap.Command{
+		Name:      strings.ToUpper(name), // Command names are case-insensitive
+		Arguments: fields[1:],
+	}
+
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/commands/unselect.go
+++ b/vendor/github.com/emersion/go-imap/commands/unselect.go
@@ -0,0 +1,17 @@
+package commands
+
+import (
+	"github.com/emersion/go-imap"
+)
+
+// An UNSELECT command.
+// See RFC 3691 section 2.
+type Unselect struct{}
+
+func (cmd *Unselect) Command() *imap.Command {
+	return &imap.Command{Name: "UNSELECT"}
+}
+
+func (cmd *Unselect) Parse(fields []interface{}) error {
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/conn.go
+++ b/vendor/github.com/emersion/go-imap/conn.go
@@ -0,0 +1,284 @@
+package imap
+
+import (
+	"bufio"
+	"crypto/tls"
+	"io"
+	"net"
+	"sync"
+)
+
+// A connection state.
+// See RFC 3501 section 3.
+type ConnState int
+
+const (
+	// In the connecting state, the server has not yet sent a greeting and no
+	// command can be issued.
+	ConnectingState = 0
+
+	// In the not authenticated state, the client MUST supply
+	// authentication credentials before most commands will be
+	// permitted.  This state is entered when a connection starts
+	// unless the connection has been pre-authenticated.
+	NotAuthenticatedState ConnState = 1 << 0
+
+	// In the authenticated state, the client is authenticated and MUST
+	// select a mailbox to access before commands that affect messages
+	// will be permitted.  This state is entered when a
+	// pre-authenticated connection starts, when acceptable
+	// authentication credentials have been provided, after an error in
+	// selecting a mailbox, or after a successful CLOSE command.
+	AuthenticatedState = 1 << 1
+
+	// In a selected state, a mailbox has been selected to access.
+	// This state is entered when a mailbox has been successfully
+	// selected.
+	SelectedState = AuthenticatedState + 1<<2
+
+	// In the logout state, the connection is being terminated. This
+	// state can be entered as a result of a client request (via the
+	// LOGOUT command) or by unilateral action on the part of either
+	// the client or server.
+	LogoutState = 1 << 3
+
+	// ConnectedState is either NotAuthenticatedState, AuthenticatedState or
+	// SelectedState.
+	ConnectedState = NotAuthenticatedState | AuthenticatedState | SelectedState
+)
+
+// A function that upgrades a connection.
+//
+// This should only be used by libraries implementing an IMAP extension (e.g.
+// COMPRESS).
+type ConnUpgrader func(conn net.Conn) (net.Conn, error)
+
+type Waiter struct {
+	start    sync.WaitGroup
+	end      sync.WaitGroup
+	finished bool
+}
+
+func NewWaiter() *Waiter {
+	w := &Waiter{finished: false}
+	w.start.Add(1)
+	w.end.Add(1)
+	return w
+}
+
+func (w *Waiter) Wait() {
+	if !w.finished {
+		// Signal that we are ready for upgrade to continue.
+		w.start.Done()
+		// Wait for upgrade to finish.
+		w.end.Wait()
+		w.finished = true
+	}
+}
+
+func (w *Waiter) WaitReady() {
+	if !w.finished {
+		// Wait for reader/writer goroutine to be ready for upgrade.
+		w.start.Wait()
+	}
+}
+
+func (w *Waiter) Close() {
+	if !w.finished {
+		// Upgrade is finished, close chanel to release reader/writer
+		w.end.Done()
+	}
+}
+
+type LockedWriter struct {
+	lock   sync.Mutex
+	writer io.Writer
+}
+
+// NewLockedWriter - goroutine safe writer.
+func NewLockedWriter(w io.Writer) io.Writer {
+	return &LockedWriter{writer: w}
+}
+
+func (w *LockedWriter) Write(b []byte) (int, error) {
+	w.lock.Lock()
+	defer w.lock.Unlock()
+	return w.writer.Write(b)
+}
+
+type debugWriter struct {
+	io.Writer
+
+	local  io.Writer
+	remote io.Writer
+}
+
+// NewDebugWriter creates a new io.Writer that will write local network activity
+// to local and remote network activity to remote.
+func NewDebugWriter(local, remote io.Writer) io.Writer {
+	return &debugWriter{Writer: local, local: local, remote: remote}
+}
+
+type multiFlusher struct {
+	flushers []flusher
+}
+
+func (mf *multiFlusher) Flush() error {
+	for _, f := range mf.flushers {
+		if err := f.Flush(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func newMultiFlusher(flushers ...flusher) flusher {
+	return &multiFlusher{flushers}
+}
+
+// Underlying connection state information.
+type ConnInfo struct {
+	RemoteAddr net.Addr
+	LocalAddr  net.Addr
+
+	// nil if connection is not using TLS.
+	TLS *tls.ConnectionState
+}
+
+// An IMAP connection.
+type Conn struct {
+	net.Conn
+	*Reader
+	*Writer
+
+	br *bufio.Reader
+	bw *bufio.Writer
+
+	waiter *Waiter
+
+	// Print all commands and responses to this io.Writer.
+	debug io.Writer
+}
+
+// NewConn creates a new IMAP connection.
+func NewConn(conn net.Conn, r *Reader, w *Writer) *Conn {
+	c := &Conn{Conn: conn, Reader: r, Writer: w}
+
+	c.init()
+	return c
+}
+
+func (c *Conn) createWaiter() *Waiter {
+	// create new waiter each time.
+	w := NewWaiter()
+	c.waiter = w
+	return w
+}
+
+func (c *Conn) init() {
+	r := io.Reader(c.Conn)
+	w := io.Writer(c.Conn)
+
+	if c.debug != nil {
+		localDebug, remoteDebug := c.debug, c.debug
+		if debug, ok := c.debug.(*debugWriter); ok {
+			localDebug, remoteDebug = debug.local, debug.remote
+		}
+		// If local and remote are the same, then we need a LockedWriter.
+		if localDebug == remoteDebug {
+			localDebug = NewLockedWriter(localDebug)
+			remoteDebug = localDebug
+		}
+
+		if localDebug != nil {
+			w = io.MultiWriter(c.Conn, localDebug)
+		}
+		if remoteDebug != nil {
+			r = io.TeeReader(c.Conn, remoteDebug)
+		}
+	}
+
+	if c.br == nil {
+		c.br = bufio.NewReader(r)
+		c.Reader.reader = c.br
+	} else {
+		c.br.Reset(r)
+	}
+
+	if c.bw == nil {
+		c.bw = bufio.NewWriter(w)
+		c.Writer.Writer = c.bw
+	} else {
+		c.bw.Reset(w)
+	}
+
+	if f, ok := c.Conn.(flusher); ok {
+		c.Writer.Writer = struct {
+			io.Writer
+			flusher
+		}{
+			c.bw,
+			newMultiFlusher(c.bw, f),
+		}
+	}
+}
+
+func (c *Conn) Info() *ConnInfo {
+	info := &ConnInfo{
+		RemoteAddr: c.RemoteAddr(),
+		LocalAddr:  c.LocalAddr(),
+	}
+
+	tlsConn, ok := c.Conn.(*tls.Conn)
+	if ok {
+		state := tlsConn.ConnectionState()
+		info.TLS = &state
+	}
+
+	return info
+}
+
+// Write implements io.Writer.
+func (c *Conn) Write(b []byte) (n int, err error) {
+	return c.Writer.Write(b)
+}
+
+// Flush writes any buffered data to the underlying connection.
+func (c *Conn) Flush() error {
+	return c.Writer.Flush()
+}
+
+// Upgrade a connection, e.g. wrap an unencrypted connection with an encrypted
+// tunnel.
+func (c *Conn) Upgrade(upgrader ConnUpgrader) error {
+	// Block reads and writes during the upgrading process
+	w := c.createWaiter()
+	defer w.Close()
+
+	upgraded, err := upgrader(c.Conn)
+	if err != nil {
+		return err
+	}
+
+	c.Conn = upgraded
+	c.init()
+	return nil
+}
+
+// Called by reader/writer goroutines to wait for Upgrade to finish
+func (c *Conn) Wait() {
+	c.waiter.Wait()
+}
+
+// Called by Upgrader to wait for reader/writer goroutines to be ready for
+// upgrade.
+func (c *Conn) WaitReady() {
+	c.waiter.WaitReady()
+}
+
+// SetDebug defines an io.Writer to which all network activity will be logged.
+// If nil is provided, network activity will not be logged.
+func (c *Conn) SetDebug(w io.Writer) {
+	c.debug = w
+	c.init()
+}
--- a/vendor/github.com/emersion/go-imap/date.go
+++ b/vendor/github.com/emersion/go-imap/date.go
@@ -0,0 +1,71 @@
+package imap
+
+import (
+	"fmt"
+	"regexp"
+	"time"
+)
+
+// Date and time layouts.
+// Dovecot adds a leading zero to dates:
+//   https://github.com/dovecot/core/blob/4fbd5c5e113078e72f29465ccc96d44955ceadc2/src/lib-imap/imap-date.c#L166
+// Cyrus adds a leading space to dates:
+//   https://github.com/cyrusimap/cyrus-imapd/blob/1cb805a3bffbdf829df0964f3b802cdc917e76db/lib/times.c#L543
+// GMail doesn't support leading spaces in dates used in SEARCH commands.
+const (
+	// Defined in RFC 3501 as date-text on page 83.
+	DateLayout = "_2-Jan-2006"
+	// Defined in RFC 3501 as date-time on page 83.
+	DateTimeLayout = "_2-Jan-2006 15:04:05 -0700"
+	// Defined in RFC 5322 section 3.3, mentioned as env-date in RFC 3501 page 84.
+	envelopeDateTimeLayout = "Mon, 02 Jan 2006 15:04:05 -0700"
+	// Use as an example in RFC 3501 page 54.
+	searchDateLayout = "2-Jan-2006"
+)
+
+// time.Time with a specific layout.
+type (
+	Date             time.Time
+	DateTime         time.Time
+	envelopeDateTime time.Time
+	searchDate       time.Time
+)
+
+// Permutations of the layouts defined in RFC 5322, section 3.3.
+var envelopeDateTimeLayouts = [...]string{
+	envelopeDateTimeLayout, // popular, try it first
+	"_2 Jan 2006 15:04:05 -0700",
+	"_2 Jan 2006 15:04:05 MST",
+	"_2 Jan 2006 15:04 -0700",
+	"_2 Jan 2006 15:04 MST",
+	"_2 Jan 06 15:04:05 -0700",
+	"_2 Jan 06 15:04:05 MST",
+	"_2 Jan 06 15:04 -0700",
+	"_2 Jan 06 15:04 MST",
+	"Mon, _2 Jan 2006 15:04:05 -0700",
+	"Mon, _2 Jan 2006 15:04:05 MST",
+	"Mon, _2 Jan 2006 15:04 -0700",
+	"Mon, _2 Jan 2006 15:04 MST",
+	"Mon, _2 Jan 06 15:04:05 -0700",
+	"Mon, _2 Jan 06 15:04:05 MST",
+	"Mon, _2 Jan 06 15:04 -0700",
+	"Mon, _2 Jan 06 15:04 MST",
+}
+
+// TODO: this is a blunt way to strip any trailing CFWS (comment). A sharper
+// one would strip multiple CFWS, and only if really valid according to
+// RFC5322.
+var commentRE = regexp.MustCompile(`[ \t]+\(.*\)$`)
+
+// Try parsing the date based on the layouts defined in RFC 5322, section 3.3.
+// Inspired by https://github.com/golang/go/blob/master/src/net/mail/message.go
+func parseMessageDateTime(maybeDate string) (time.Time, error) {
+	maybeDate = commentRE.ReplaceAllString(maybeDate, "")
+	for _, layout := range envelopeDateTimeLayouts {
+		parsed, err := time.Parse(layout, maybeDate)
+		if err == nil {
+			return parsed, nil
+		}
+	}
+	return time.Time{}, fmt.Errorf("date %s could not be parsed", maybeDate)
+}
--- a/vendor/github.com/emersion/go-imap/imap.go
+++ b/vendor/github.com/emersion/go-imap/imap.go
@@ -0,0 +1,108 @@
+// Package imap implements IMAP4rev1 (RFC 3501).
+package imap
+
+import (
+	"errors"
+	"io"
+	"strings"
+)
+
+// A StatusItem is a mailbox status data item that can be retrieved with a
+// STATUS command. See RFC 3501 section 6.3.10.
+type StatusItem string
+
+const (
+	StatusMessages    StatusItem = "MESSAGES"
+	StatusRecent      StatusItem = "RECENT"
+	StatusUidNext     StatusItem = "UIDNEXT"
+	StatusUidValidity StatusItem = "UIDVALIDITY"
+	StatusUnseen      StatusItem = "UNSEEN"
+
+	StatusAppendLimit StatusItem = "APPENDLIMIT"
+)
+
+// A FetchItem is a message data item that can be fetched.
+type FetchItem string
+
+// List of items that can be fetched.
+const (
+	// Macros
+	FetchAll  FetchItem = "ALL"
+	FetchFast FetchItem = "FAST"
+	FetchFull FetchItem = "FULL"
+
+	// Items
+	FetchBody          FetchItem = "BODY"
+	FetchBodyStructure FetchItem = "BODYSTRUCTURE"
+	FetchEnvelope      FetchItem = "ENVELOPE"
+	FetchFlags         FetchItem = "FLAGS"
+	FetchInternalDate  FetchItem = "INTERNALDATE"
+	FetchRFC822        FetchItem = "RFC822"
+	FetchRFC822Header  FetchItem = "RFC822.HEADER"
+	FetchRFC822Size    FetchItem = "RFC822.SIZE"
+	FetchRFC822Text    FetchItem = "RFC822.TEXT"
+	FetchUid           FetchItem = "UID"
+)
+
+// Expand expands the item if it's a macro.
+func (item FetchItem) Expand() []FetchItem {
+	switch item {
+	case FetchAll:
+		return []FetchItem{FetchFlags, FetchInternalDate, FetchRFC822Size, FetchEnvelope}
+	case FetchFast:
+		return []FetchItem{FetchFlags, FetchInternalDate, FetchRFC822Size}
+	case FetchFull:
+		return []FetchItem{FetchFlags, FetchInternalDate, FetchRFC822Size, FetchEnvelope, FetchBody}
+	default:
+		return []FetchItem{item}
+	}
+}
+
+// FlagsOp is an operation that will be applied on message flags.
+type FlagsOp string
+
+const (
+	// SetFlags replaces existing flags by new ones.
+	SetFlags FlagsOp = "FLAGS"
+	// AddFlags adds new flags.
+	AddFlags = "+FLAGS"
+	// RemoveFlags removes existing flags.
+	RemoveFlags = "-FLAGS"
+)
+
+// silentOp can be appended to a FlagsOp to prevent the operation from
+// triggering unilateral message updates.
+const silentOp = ".SILENT"
+
+// A StoreItem is a message data item that can be updated.
+type StoreItem string
+
+// FormatFlagsOp returns the StoreItem that executes the flags operation op.
+func FormatFlagsOp(op FlagsOp, silent bool) StoreItem {
+	s := string(op)
+	if silent {
+		s += silentOp
+	}
+	return StoreItem(s)
+}
+
+// ParseFlagsOp parses a flags operation from StoreItem.
+func ParseFlagsOp(item StoreItem) (op FlagsOp, silent bool, err error) {
+	itemStr := string(item)
+	silent = strings.HasSuffix(itemStr, silentOp)
+	if silent {
+		itemStr = strings.TrimSuffix(itemStr, silentOp)
+	}
+	op = FlagsOp(itemStr)
+
+	if op != SetFlags && op != AddFlags && op != RemoveFlags {
+		err = errors.New("Unsupported STORE operation")
+	}
+	return
+}
+
+// CharsetReader, if non-nil, defines a function to generate charset-conversion
+// readers, converting from the provided charset into UTF-8. Charsets are always
+// lower-case. utf-8 and us-ascii charsets are handled by default. One of the
+// the CharsetReader's result values must be non-nil.
+var CharsetReader func(charset string, r io.Reader) (io.Reader, error)
--- a/vendor/github.com/emersion/go-imap/literal.go
+++ b/vendor/github.com/emersion/go-imap/literal.go
@@ -0,0 +1,13 @@
+package imap
+
+import (
+	"io"
+)
+
+// A literal, as defined in RFC 3501 section 4.3.
+type Literal interface {
+	io.Reader
+
+	// Len returns the number of bytes of the literal.
+	Len() int
+}
--- a/vendor/github.com/emersion/go-imap/logger.go
+++ b/vendor/github.com/emersion/go-imap/logger.go
@@ -0,0 +1,8 @@
+package imap
+
+// Logger is the behaviour used by server/client to
+// report errors for accepting connections and unexpected behavior from handlers.
+type Logger interface {
+	Printf(format string, v ...interface{})
+	Println(v ...interface{})
+}
--- a/vendor/github.com/emersion/go-imap/mailbox.go
+++ b/vendor/github.com/emersion/go-imap/mailbox.go
@@ -0,0 +1,314 @@
+package imap
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+
+	"github.com/emersion/go-imap/utf7"
+)
+
+// The primary mailbox, as defined in RFC 3501 section 5.1.
+const InboxName = "INBOX"
+
+// CanonicalMailboxName returns the canonical form of a mailbox name. Mailbox names can be
+// case-sensitive or case-insensitive depending on the backend implementation.
+// The special INBOX mailbox is case-insensitive.
+func CanonicalMailboxName(name string) string {
+	if strings.EqualFold(name, InboxName) {
+		return InboxName
+	}
+	return name
+}
+
+// Mailbox attributes definied in RFC 3501 section 7.2.2.
+const (
+	// It is not possible for any child levels of hierarchy to exist under this\
+	// name; no child levels exist now and none can be created in the future.
+	NoInferiorsAttr = "\\Noinferiors"
+	// It is not possible to use this name as a selectable mailbox.
+	NoSelectAttr = "\\Noselect"
+	// The mailbox has been marked "interesting" by the server; the mailbox
+	// probably contains messages that have been added since the last time the
+	// mailbox was selected.
+	MarkedAttr = "\\Marked"
+	// The mailbox does not contain any additional messages since the last time
+	// the mailbox was selected.
+	UnmarkedAttr = "\\Unmarked"
+)
+
+// Mailbox attributes defined in RFC 6154 section 2 (SPECIAL-USE extension).
+const (
+	// This mailbox presents all messages in the user's message store.
+	AllAttr = "\\All"
+	// This mailbox is used to archive messages.
+	ArchiveAttr = "\\Archive"
+	// This mailbox is used to hold draft messages -- typically, messages that are
+	// being composed but have not yet been sent.
+	DraftsAttr = "\\Drafts"
+	// This mailbox presents all messages marked in some way as "important".
+	FlaggedAttr = "\\Flagged"
+	// This mailbox is where messages deemed to be junk mail are held.
+	JunkAttr = "\\Junk"
+	// This mailbox is used to hold copies of messages that have been sent.
+	SentAttr = "\\Sent"
+	// This mailbox is used to hold messages that have been deleted or marked for
+	// deletion.
+	TrashAttr = "\\Trash"
+)
+
+// Mailbox attributes defined in RFC 3348 (CHILDREN extension)
+const (
+	// The presence of this attribute indicates that the mailbox has child
+	// mailboxes.
+	HasChildrenAttr = "\\HasChildren"
+	// The presence of this attribute indicates that the mailbox has no child
+	// mailboxes.
+	HasNoChildrenAttr = "\\HasNoChildren"
+)
+
+// This mailbox attribute is a signal that the mailbox contains messages that
+// are likely important to the user. This attribute is defined in RFC 8457
+// section 3.
+const ImportantAttr = "\\Important"
+
+// Basic mailbox info.
+type MailboxInfo struct {
+	// The mailbox attributes.
+	Attributes []string
+	// The server's path separator.
+	Delimiter string
+	// The mailbox name.
+	Name string
+}
+
+// Parse mailbox info from fields.
+func (info *MailboxInfo) Parse(fields []interface{}) error {
+	if len(fields) < 3 {
+		return errors.New("Mailbox info needs at least 3 fields")
+	}
+
+	var err error
+	if info.Attributes, err = ParseStringList(fields[0]); err != nil {
+		return err
+	}
+
+	var ok bool
+	if info.Delimiter, ok = fields[1].(string); !ok {
+		// The delimiter may be specified as NIL, which gets converted to a nil interface.
+		if fields[1] != nil {
+			return errors.New("Mailbox delimiter must be a string")
+		}
+		info.Delimiter = ""
+	}
+
+	if name, err := ParseString(fields[2]); err != nil {
+		return err
+	} else if name, err := utf7.Encoding.NewDecoder().String(name); err != nil {
+		return err
+	} else {
+		info.Name = CanonicalMailboxName(name)
+	}
+
+	return nil
+}
+
+// Format mailbox info to fields.
+func (info *MailboxInfo) Format() []interface{} {
+	name, _ := utf7.Encoding.NewEncoder().String(info.Name)
+	attrs := make([]interface{}, len(info.Attributes))
+	for i, attr := range info.Attributes {
+		attrs[i] = RawString(attr)
+	}
+
+	// If the delimiter is NIL, we need to treat it specially by inserting
+	// a nil field (so that it's later converted to an unquoted NIL atom).
+	var del interface{}
+
+	if info.Delimiter != "" {
+		del = info.Delimiter
+	}
+
+	// Thunderbird doesn't understand delimiters if not quoted
+	return []interface{}{attrs, del, FormatMailboxName(name)}
+}
+
+// TODO: optimize this
+func (info *MailboxInfo) match(name, pattern string) bool {
+	i := strings.IndexAny(pattern, "*%")
+	if i == -1 {
+		// No more wildcards
+		return name == pattern
+	}
+
+	// Get parts before and after wildcard
+	chunk, wildcard, rest := pattern[0:i], pattern[i], pattern[i+1:]
+
+	// Check that name begins with chunk
+	if len(chunk) > 0 && !strings.HasPrefix(name, chunk) {
+		return false
+	}
+	name = strings.TrimPrefix(name, chunk)
+
+	// Expand wildcard
+	var j int
+	for j = 0; j < len(name); j++ {
+		if wildcard == '%' && string(name[j]) == info.Delimiter {
+			break // Stop on delimiter if wildcard is %
+		}
+		// Try to match the rest from here
+		if info.match(name[j:], rest) {
+			return true
+		}
+	}
+
+	return info.match(name[j:], rest)
+}
+
+// Match checks if a reference and a pattern matches this mailbox name, as
+// defined in RFC 3501 section 6.3.8.
+func (info *MailboxInfo) Match(reference, pattern string) bool {
+	name := info.Name
+
+	if info.Delimiter != "" && strings.HasPrefix(pattern, info.Delimiter) {
+		reference = ""
+		pattern = strings.TrimPrefix(pattern, info.Delimiter)
+	}
+	if reference != "" {
+		if info.Delimiter != "" && !strings.HasSuffix(reference, info.Delimiter) {
+			reference += info.Delimiter
+		}
+		if !strings.HasPrefix(name, reference) {
+			return false
+		}
+		name = strings.TrimPrefix(name, reference)
+	}
+
+	return info.match(name, pattern)
+}
+
+// A mailbox status.
+type MailboxStatus struct {
+	// The mailbox name.
+	Name string
+	// True if the mailbox is open in read-only mode.
+	ReadOnly bool
+	// The mailbox items that are currently filled in. This map's values
+	// should not be used directly, they must only be used by libraries
+	// implementing extensions of the IMAP protocol.
+	Items map[StatusItem]interface{}
+
+	// The Items map may be accessed in different goroutines. Protect
+	// concurrent writes.
+	ItemsLocker sync.Mutex
+
+	// The mailbox flags.
+	Flags []string
+	// The mailbox permanent flags.
+	PermanentFlags []string
+	// The sequence number of the first unseen message in the mailbox.
+	UnseenSeqNum uint32
+
+	// The number of messages in this mailbox.
+	Messages uint32
+	// The number of messages not seen since the last time the mailbox was opened.
+	Recent uint32
+	// The number of unread messages.
+	Unseen uint32
+	// The next UID.
+	UidNext uint32
+	// Together with a UID, it is a unique identifier for a message.
+	// Must be greater than or equal to 1.
+	UidValidity uint32
+
+	// Per-mailbox limit of message size. Set only if server supports the
+	// APPENDLIMIT extension.
+	AppendLimit uint32
+}
+
+// Create a new mailbox status that will contain the specified items.
+func NewMailboxStatus(name string, items []StatusItem) *MailboxStatus {
+	status := &MailboxStatus{
+		Name:  name,
+		Items: make(map[StatusItem]interface{}),
+	}
+
+	for _, k := range items {
+		status.Items[k] = nil
+	}
+
+	return status
+}
+
+func (status *MailboxStatus) Parse(fields []interface{}) error {
+	status.Items = make(map[StatusItem]interface{})
+
+	var k StatusItem
+	for i, f := range fields {
+		if i%2 == 0 {
+			if kstr, ok := f.(string); !ok {
+				return fmt.Errorf("cannot parse mailbox status: key is not a string, but a %T", f)
+			} else {
+				k = StatusItem(strings.ToUpper(kstr))
+			}
+		} else {
+			status.Items[k] = nil
+
+			var err error
+			switch k {
+			case StatusMessages:
+				status.Messages, err = ParseNumber(f)
+			case StatusRecent:
+				status.Recent, err = ParseNumber(f)
+			case StatusUnseen:
+				status.Unseen, err = ParseNumber(f)
+			case StatusUidNext:
+				status.UidNext, err = ParseNumber(f)
+			case StatusUidValidity:
+				status.UidValidity, err = ParseNumber(f)
+			case StatusAppendLimit:
+				status.AppendLimit, err = ParseNumber(f)
+			default:
+				status.Items[k] = f
+			}
+
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func (status *MailboxStatus) Format() []interface{} {
+	var fields []interface{}
+	for k, v := range status.Items {
+		switch k {
+		case StatusMessages:
+			v = status.Messages
+		case StatusRecent:
+			v = status.Recent
+		case StatusUnseen:
+			v = status.Unseen
+		case StatusUidNext:
+			v = status.UidNext
+		case StatusUidValidity:
+			v = status.UidValidity
+		case StatusAppendLimit:
+			v = status.AppendLimit
+		}
+
+		fields = append(fields, RawString(k), v)
+	}
+	return fields
+}
+
+func FormatMailboxName(name string) interface{} {
+	// Some e-mails servers don't handle quoted INBOX names correctly so we special-case it.
+	if strings.EqualFold(name, "INBOX") {
+		return RawString(name)
+	}
+	return name
+}
--- a/vendor/github.com/emersion/go-imap/message.go
+++ b/vendor/github.com/emersion/go-imap/message.go
--- a/vendor/github.com/emersion/go-imap/read.go
+++ b/vendor/github.com/emersion/go-imap/read.go
@@ -0,0 +1,467 @@
+package imap
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"strconv"
+	"strings"
+)
+
+const (
+	sp            = ' '
+	cr            = '\r'
+	lf            = '\n'
+	dquote        = '"'
+	literalStart  = '{'
+	literalEnd    = '}'
+	listStart     = '('
+	listEnd       = ')'
+	respCodeStart = '['
+	respCodeEnd   = ']'
+)
+
+const (
+	crlf    = "\r\n"
+	nilAtom = "NIL"
+)
+
+// TODO: add CTL to atomSpecials
+var (
+	quotedSpecials = string([]rune{dquote, '\\'})
+	respSpecials   = string([]rune{respCodeEnd})
+	atomSpecials   = string([]rune{listStart, listEnd, literalStart, sp, '%', '*'}) + quotedSpecials + respSpecials
+)
+
+type parseError struct {
+	error
+}
+
+func newParseError(text string) error {
+	return &parseError{errors.New(text)}
+}
+
+// IsParseError returns true if the provided error is a parse error produced by
+// Reader.
+func IsParseError(err error) bool {
+	_, ok := err.(*parseError)
+	return ok
+}
+
+// A string reader.
+type StringReader interface {
+	// ReadString reads until the first occurrence of delim in the input,
+	// returning a string containing the data up to and including the delimiter.
+	// See https://golang.org/pkg/bufio/#Reader.ReadString
+	ReadString(delim byte) (line string, err error)
+}
+
+type reader interface {
+	io.Reader
+	io.RuneScanner
+	StringReader
+}
+
+// ParseNumber parses a number.
+func ParseNumber(f interface{}) (uint32, error) {
+	// Useful for tests
+	if n, ok := f.(uint32); ok {
+		return n, nil
+	}
+
+	var s string
+	switch f := f.(type) {
+	case RawString:
+		s = string(f)
+	case string:
+		s = f
+	default:
+		return 0, newParseError("expected a number, got a non-atom")
+	}
+
+	nbr, err := strconv.ParseUint(string(s), 10, 32)
+	if err != nil {
+		return 0, &parseError{err}
+	}
+
+	return uint32(nbr), nil
+}
+
+// ParseString parses a string, which is either a literal, a quoted string or an
+// atom.
+func ParseString(f interface{}) (string, error) {
+	if s, ok := f.(string); ok {
+		return s, nil
+	}
+
+	// Useful for tests
+	if a, ok := f.(RawString); ok {
+		return string(a), nil
+	}
+
+	if l, ok := f.(Literal); ok {
+		b := make([]byte, l.Len())
+		if _, err := io.ReadFull(l, b); err != nil {
+			return "", err
+		}
+		return string(b), nil
+	}
+
+	return "", newParseError("expected a string")
+}
+
+// Convert a field list to a string list.
+func ParseStringList(f interface{}) ([]string, error) {
+	fields, ok := f.([]interface{})
+	if !ok {
+		return nil, newParseError("expected a string list, got a non-list")
+	}
+
+	list := make([]string, len(fields))
+	for i, f := range fields {
+		var err error
+		if list[i], err = ParseString(f); err != nil {
+			return nil, newParseError("cannot parse string in string list: " + err.Error())
+		}
+	}
+	return list, nil
+}
+
+func trimSuffix(str string, suffix rune) string {
+	return str[:len(str)-1]
+}
+
+// An IMAP reader.
+type Reader struct {
+	MaxLiteralSize uint32 // The maximum literal size.
+
+	reader
+
+	continues chan<- bool
+
+	brackets   int
+	inRespCode bool
+}
+
+func (r *Reader) ReadSp() error {
+	char, _, err := r.ReadRune()
+	if err != nil {
+		return err
+	}
+	if char != sp {
+		return newParseError("expected a space")
+	}
+	return nil
+}
+
+func (r *Reader) ReadCrlf() (err error) {
+	var char rune
+
+	if char, _, err = r.ReadRune(); err != nil {
+		return
+	}
+	if char == lf {
+		return
+	}
+	if char != cr {
+		err = newParseError("line doesn't end with a CR")
+		return
+	}
+
+	if char, _, err = r.ReadRune(); err != nil {
+		return
+	}
+	if char != lf {
+		err = newParseError("line doesn't end with a LF")
+	}
+
+	return
+}
+
+func (r *Reader) ReadAtom() (interface{}, error) {
+	r.brackets = 0
+
+	var atom string
+	for {
+		char, _, err := r.ReadRune()
+		if err != nil {
+			return nil, err
+		}
+
+		// TODO: list-wildcards and \
+		if r.brackets == 0 && (char == listStart || char == literalStart || char == dquote) {
+			return nil, newParseError("atom contains forbidden char: " + string(char))
+		}
+		if char == cr || char == lf {
+			break
+		}
+		if r.brackets == 0 && (char == sp || char == listEnd) {
+			break
+		}
+		if char == respCodeEnd {
+			if r.brackets == 0 {
+				if r.inRespCode {
+					break
+				} else {
+					return nil, newParseError("atom contains bad brackets nesting")
+				}
+			}
+			r.brackets--
+		}
+		if char == respCodeStart {
+			r.brackets++
+		}
+
+		atom += string(char)
+	}
+
+	r.UnreadRune()
+
+	if atom == nilAtom {
+		return nil, nil
+	}
+
+	return atom, nil
+}
+
+func (r *Reader) ReadLiteral() (Literal, error) {
+	char, _, err := r.ReadRune()
+	if err != nil {
+		return nil, err
+	} else if char != literalStart {
+		return nil, newParseError("literal string doesn't start with an open brace")
+	}
+
+	lstr, err := r.ReadString(byte(literalEnd))
+	if err != nil {
+		return nil, err
+	}
+	lstr = trimSuffix(lstr, literalEnd)
+
+	nonSync := strings.HasSuffix(lstr, "+")
+	if nonSync {
+		lstr = trimSuffix(lstr, '+')
+	}
+
+	n, err := strconv.ParseUint(lstr, 10, 32)
+	if err != nil {
+		return nil, newParseError("cannot parse literal length: " + err.Error())
+	}
+	if r.MaxLiteralSize > 0 && uint32(n) > r.MaxLiteralSize {
+		return nil, newParseError("literal exceeding maximum size")
+	}
+
+	if err := r.ReadCrlf(); err != nil {
+		return nil, err
+	}
+
+	// Send continuation request if necessary
+	if r.continues != nil && !nonSync {
+		r.continues <- true
+	}
+
+	// Read literal
+	b := make([]byte, n)
+	if _, err := io.ReadFull(r, b); err != nil {
+		return nil, err
+	}
+	return bytes.NewBuffer(b), nil
+}
+
+func (r *Reader) ReadQuotedString() (string, error) {
+	if char, _, err := r.ReadRune(); err != nil {
+		return "", err
+	} else if char != dquote {
+		return "", newParseError("quoted string doesn't start with a double quote")
+	}
+
+	var buf bytes.Buffer
+	var escaped bool
+	for {
+		char, _, err := r.ReadRune()
+		if err != nil {
+			return "", err
+		}
+
+		if char == '\\' && !escaped {
+			escaped = true
+		} else {
+			if char == cr || char == lf {
+				r.UnreadRune()
+				return "", newParseError("CR or LF not allowed in quoted string")
+			}
+			if char == dquote && !escaped {
+				break
+			}
+
+			if !strings.ContainsRune(quotedSpecials, char) && escaped {
+				return "", newParseError("quoted string cannot contain backslash followed by a non-quoted-specials char")
+			}
+
+			buf.WriteRune(char)
+			escaped = false
+		}
+	}
+
+	return buf.String(), nil
+}
+
+func (r *Reader) ReadFields() (fields []interface{}, err error) {
+	var char rune
+	for {
+		if char, _, err = r.ReadRune(); err != nil {
+			return
+		}
+		if err = r.UnreadRune(); err != nil {
+			return
+		}
+
+		var field interface{}
+		ok := true
+		switch char {
+		case literalStart:
+			field, err = r.ReadLiteral()
+		case dquote:
+			field, err = r.ReadQuotedString()
+		case listStart:
+			field, err = r.ReadList()
+		case listEnd:
+			ok = false
+		case cr:
+			return
+		default:
+			field, err = r.ReadAtom()
+		}
+
+		if err != nil {
+			return
+		}
+		if ok {
+			fields = append(fields, field)
+		}
+
+		if char, _, err = r.ReadRune(); err != nil {
+			return
+		}
+		if char == cr || char == lf || char == listEnd || char == respCodeEnd {
+			if char == cr || char == lf {
+				r.UnreadRune()
+			}
+			return
+		}
+		if char == listStart {
+			r.UnreadRune()
+			continue
+		}
+		if char != sp {
+			err = newParseError("fields are not separated by a space")
+			return
+		}
+	}
+}
+
+func (r *Reader) ReadList() (fields []interface{}, err error) {
+	char, _, err := r.ReadRune()
+	if err != nil {
+		return
+	}
+	if char != listStart {
+		err = newParseError("list doesn't start with an open parenthesis")
+		return
+	}
+
+	fields, err = r.ReadFields()
+	if err != nil {
+		return
+	}
+
+	r.UnreadRune()
+	if char, _, err = r.ReadRune(); err != nil {
+		return
+	}
+	if char != listEnd {
+		err = newParseError("list doesn't end with a close parenthesis")
+	}
+	return
+}
+
+func (r *Reader) ReadLine() (fields []interface{}, err error) {
+	fields, err = r.ReadFields()
+	if err != nil {
+		return
+	}
+
+	r.UnreadRune()
+	err = r.ReadCrlf()
+	return
+}
+
+func (r *Reader) ReadRespCode() (code StatusRespCode, fields []interface{}, err error) {
+	char, _, err := r.ReadRune()
+	if err != nil {
+		return
+	}
+	if char != respCodeStart {
+		err = newParseError("response code doesn't start with an open bracket")
+		return
+	}
+
+	r.inRespCode = true
+	fields, err = r.ReadFields()
+	r.inRespCode = false
+	if err != nil {
+		return
+	}
+
+	if len(fields) == 0 {
+		err = newParseError("response code doesn't contain any field")
+		return
+	}
+
+	codeStr, ok := fields[0].(string)
+	if !ok {
+		err = newParseError("response code doesn't start with a string atom")
+		return
+	}
+	if codeStr == "" {
+		err = newParseError("response code is empty")
+		return
+	}
+	code = StatusRespCode(strings.ToUpper(codeStr))
+
+	fields = fields[1:]
+
+	r.UnreadRune()
+	char, _, err = r.ReadRune()
+	if err != nil {
+		return
+	}
+	if char != respCodeEnd {
+		err = newParseError("response code doesn't end with a close bracket")
+	}
+	return
+}
+
+func (r *Reader) ReadInfo() (info string, err error) {
+	info, err = r.ReadString(byte(lf))
+	if err != nil {
+		return
+	}
+	info = strings.TrimSuffix(info, string(lf))
+	info = strings.TrimSuffix(info, string(cr))
+	info = strings.TrimLeft(info, " ")
+
+	return
+}
+
+func NewReader(r reader) *Reader {
+	return &Reader{reader: r}
+}
+
+func NewServerReader(r reader, continues chan<- bool) *Reader {
+	return &Reader{reader: r, continues: continues}
+}
+
+type Parser interface {
+	Parse(fields []interface{}) error
+}
--- a/vendor/github.com/emersion/go-imap/response.go
+++ b/vendor/github.com/emersion/go-imap/response.go
@@ -0,0 +1,181 @@
+package imap
+
+import (
+	"strings"
+)
+
+// Resp is an IMAP response. It is either a *DataResp, a
+// *ContinuationReq or a *StatusResp.
+type Resp interface {
+	resp()
+}
+
+// ReadResp reads a single response from a Reader.
+func ReadResp(r *Reader) (Resp, error) {
+	atom, err := r.ReadAtom()
+	if err != nil {
+		return nil, err
+	}
+	tag, ok := atom.(string)
+	if !ok {
+		return nil, newParseError("response tag is not an atom")
+	}
+
+	if tag == "+" {
+		if err := r.ReadSp(); err != nil {
+			r.UnreadRune()
+		}
+
+		resp := &ContinuationReq{}
+		resp.Info, err = r.ReadInfo()
+		if err != nil {
+			return nil, err
+		}
+
+		return resp, nil
+	}
+
+	if err := r.ReadSp(); err != nil {
+		return nil, err
+	}
+
+	// Can be either data or status
+	// Try to parse a status
+	var fields []interface{}
+	if atom, err := r.ReadAtom(); err == nil {
+		fields = append(fields, atom)
+
+		if err := r.ReadSp(); err == nil {
+			if name, ok := atom.(string); ok {
+				status := StatusRespType(name)
+				switch status {
+				case StatusRespOk, StatusRespNo, StatusRespBad, StatusRespPreauth, StatusRespBye:
+					resp := &StatusResp{
+						Tag:  tag,
+						Type: status,
+					}
+
+					char, _, err := r.ReadRune()
+					if err != nil {
+						return nil, err
+					}
+					r.UnreadRune()
+
+					if char == '[' {
+						// Contains code & arguments
+						resp.Code, resp.Arguments, err = r.ReadRespCode()
+						if err != nil {
+							return nil, err
+						}
+					}
+
+					resp.Info, err = r.ReadInfo()
+					if err != nil {
+						return nil, err
+					}
+
+					return resp, nil
+				}
+			}
+		} else {
+			r.UnreadRune()
+		}
+	} else {
+		r.UnreadRune()
+	}
+
+	// Not a status so it's data
+	resp := &DataResp{Tag: tag}
+
+	var remaining []interface{}
+	remaining, err = r.ReadLine()
+	if err != nil {
+		return nil, err
+	}
+
+	resp.Fields = append(fields, remaining...)
+	return resp, nil
+}
+
+// DataResp is an IMAP response containing data.
+type DataResp struct {
+	// The response tag. Can be either "" for untagged responses, "+" for continuation
+	// requests or a previous command's tag.
+	Tag string
+	// The parsed response fields.
+	Fields []interface{}
+}
+
+// NewUntaggedResp creates a new untagged response.
+func NewUntaggedResp(fields []interface{}) *DataResp {
+	return &DataResp{
+		Tag:    "*",
+		Fields: fields,
+	}
+}
+
+func (r *DataResp) resp() {}
+
+func (r *DataResp) WriteTo(w *Writer) error {
+	tag := RawString(r.Tag)
+	if tag == "" {
+		tag = RawString("*")
+	}
+
+	fields := []interface{}{RawString(tag)}
+	fields = append(fields, r.Fields...)
+	return w.writeLine(fields...)
+}
+
+// ContinuationReq is a continuation request response.
+type ContinuationReq struct {
+	// The info message sent with the continuation request.
+	Info string
+}
+
+func (r *ContinuationReq) resp() {}
+
+func (r *ContinuationReq) WriteTo(w *Writer) error {
+	if err := w.writeString("+"); err != nil {
+		return err
+	}
+
+	if r.Info != "" {
+		if err := w.writeString(string(sp) + r.Info); err != nil {
+			return err
+		}
+	}
+
+	return w.writeCrlf()
+}
+
+// ParseNamedResp attempts to parse a named data response.
+func ParseNamedResp(resp Resp) (name string, fields []interface{}, ok bool) {
+	data, ok := resp.(*DataResp)
+	if !ok || len(data.Fields) == 0 {
+		return
+	}
+
+	// Some responses (namely EXISTS and RECENT) are formatted like so:
+	//   [num] [name] [...]
+	// Which is fucking stupid. But we handle that here by checking if the
+	// response name is a number and then rearranging it.
+	if len(data.Fields) > 1 {
+		name, ok := data.Fields[1].(string)
+		if ok {
+			if _, err := ParseNumber(data.Fields[0]); err == nil {
+				fields := []interface{}{data.Fields[0]}
+				fields = append(fields, data.Fields[2:]...)
+				return strings.ToUpper(name), fields, true
+			}
+		}
+	}
+
+	// IMAP commands are formatted like this:
+	//   [name] [...]
+	name, ok = data.Fields[0].(string)
+	if !ok {
+		return
+	}
+	return strings.ToUpper(name), data.Fields[1:], true
+}
--- a/vendor/github.com/emersion/go-imap/responses/authenticate.go
+++ b/vendor/github.com/emersion/go-imap/responses/authenticate.go
@@ -0,0 +1,61 @@
+package responses
+
+import (
+	"encoding/base64"
+
+	"github.com/emersion/go-imap"
+	"github.com/emersion/go-sasl"
+)
+
+// An AUTHENTICATE response.
+type Authenticate struct {
+	Mechanism       sasl.Client
+	InitialResponse []byte
+	RepliesCh       chan []byte
+}
+
+// Implements
+func (r *Authenticate) Replies() <-chan []byte {
+	return r.RepliesCh
+}
+
+func (r *Authenticate) writeLine(l string) error {
+	r.RepliesCh <- []byte(l + "\r\n")
+	return nil
+}
+
+func (r *Authenticate) cancel() error {
+	return r.writeLine("*")
+}
+
+func (r *Authenticate) Handle(resp imap.Resp) error {
+	cont, ok := resp.(*imap.ContinuationReq)
+	if !ok {
+		return ErrUnhandled
+	}
+
+	// Empty challenge, send initial response as stated in RFC 2222 section 5.1
+	if cont.Info == "" && r.InitialResponse != nil {
+		encoded := base64.StdEncoding.EncodeToString(r.InitialResponse)
+		if err := r.writeLine(encoded); err != nil {
+			return err
+		}
+		r.InitialResponse = nil
+		return nil
+	}
+
+	challenge, err := base64.StdEncoding.DecodeString(cont.Info)
+	if err != nil {
+		r.cancel()
+		return err
+	}
+
+	reply, err := r.Mechanism.Next(challenge)
+	if err != nil {
+		r.cancel()
+		return err
+	}
+
+	encoded := base64.StdEncoding.EncodeToString(reply)
+	return r.writeLine(encoded)
+}
--- a/vendor/github.com/emersion/go-imap/responses/capability.go
+++ b/vendor/github.com/emersion/go-imap/responses/capability.go
@@ -0,0 +1,20 @@
+package responses
+
+import (
+	"github.com/emersion/go-imap"
+)
+
+// A CAPABILITY response.
+// See RFC 3501 section 7.2.1
+type Capability struct {
+	Caps []string
+}
+
+func (r *Capability) WriteTo(w *imap.Writer) error {
+	fields := []interface{}{imap.RawString("CAPABILITY")}
+	for _, cap := range r.Caps {
+		fields = append(fields, imap.RawString(cap))
+	}
+
+	return imap.NewUntaggedResp(fields).WriteTo(w)
+}
--- a/vendor/github.com/emersion/go-imap/responses/enabled.go
+++ b/vendor/github.com/emersion/go-imap/responses/enabled.go
@@ -0,0 +1,33 @@
+package responses
+
+import (
+	"github.com/emersion/go-imap"
+)
+
+// An ENABLED response, defined in RFC 5161 section 3.2.
+type Enabled struct {
+	Caps []string
+}
+
+func (r *Enabled) Handle(resp imap.Resp) error {
+	name, fields, ok := imap.ParseNamedResp(resp)
+	if !ok || name != "ENABLED" {
+		return ErrUnhandled
+	}
+
+	if caps, err := imap.ParseStringList(fields); err != nil {
+		return err
+	} else {
+		r.Caps = append(r.Caps, caps...)
+	}
+
+	return nil
+}
+
+func (r *Enabled) WriteTo(w *imap.Writer) error {
+	fields := []interface{}{imap.RawString("ENABLED")}
+	for _, cap := range r.Caps {
+		fields = append(fields, imap.RawString(cap))
+	}
+	return imap.NewUntaggedResp(fields).WriteTo(w)
+}
--- a/vendor/github.com/emersion/go-imap/responses/expunge.go
+++ b/vendor/github.com/emersion/go-imap/responses/expunge.go
@@ -0,0 +1,43 @@
+package responses
+
+import (
+	"github.com/emersion/go-imap"
+)
+
+const expungeName = "EXPUNGE"
+
+// An EXPUNGE response.
+// See RFC 3501 section 7.4.1
+type Expunge struct {
+	SeqNums chan uint32
+}
+
+func (r *Expunge) Handle(resp imap.Resp) error {
+	name, fields, ok := imap.ParseNamedResp(resp)
+	if !ok || name != expungeName {
+		return ErrUnhandled
+	}
+
+	if len(fields) == 0 {
+		return errNotEnoughFields
+	}
+
+	seqNum, err := imap.ParseNumber(fields[0])
+	if err != nil {
+		return err
+	}
+
+	r.SeqNums <- seqNum
+	return nil
+}
+
+func (r *Expunge) WriteTo(w *imap.Writer) error {
+	for seqNum := range r.SeqNums {
+		resp := imap.NewUntaggedResp([]interface{}{seqNum, imap.RawString(expungeName)})
+		if err := resp.WriteTo(w); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/responses/fetch.go
+++ b/vendor/github.com/emersion/go-imap/responses/fetch.go
@@ -0,0 +1,70 @@
+package responses
+
+import (
+	"github.com/emersion/go-imap"
+)
+
+const fetchName = "FETCH"
+
+// A FETCH response.
+// See RFC 3501 section 7.4.2
+type Fetch struct {
+	Messages chan *imap.Message
+	SeqSet   *imap.SeqSet
+	Uid      bool
+}
+
+func (r *Fetch) Handle(resp imap.Resp) error {
+	name, fields, ok := imap.ParseNamedResp(resp)
+	if !ok || name != fetchName {
+		return ErrUnhandled
+	} else if len(fields) < 1 {
+		return errNotEnoughFields
+	}
+
+	seqNum, err := imap.ParseNumber(fields[0])
+	if err != nil {
+		return err
+	}
+
+	msgFields, _ := fields[1].([]interface{})
+	msg := &imap.Message{SeqNum: seqNum}
+	if err := msg.Parse(msgFields); err != nil {
+		return err
+	}
+
+	if r.Uid && msg.Uid == 0 {
+		// we requested UIDs and got a message without one --> unilateral update --> ignore
+		return ErrUnhandled
+	}
+
+	var num uint32
+	if r.Uid {
+		num = msg.Uid
+	} else {
+		num = seqNum
+	}
+
+	// Check whether we obtained a result we requested with our SeqSet
+	// If the result is not contained in our SeqSet we have to handle an additional special case:
+	// In case we requested UIDs with a dynamic sequence (i.e. * or n:*) and the maximum UID of the mailbox
+	// is less then our n, the server will supply us with the max UID (cf. RFC 3501 §6.4.8 and §9 `seq-range`).
+	// Thus, such a result is correct and has to be returned by us.
+	if !r.SeqSet.Contains(num) && (!r.Uid || !r.SeqSet.Dynamic()) {
+		return ErrUnhandled
+	}
+
+	r.Messages <- msg
+	return nil
+}
+
+func (r *Fetch) WriteTo(w *imap.Writer) error {
+	var err error
+	for msg := range r.Messages {
+		resp := imap.NewUntaggedResp([]interface{}{msg.SeqNum, imap.RawString(fetchName), msg.Format()})
+		if err == nil {
+			err = resp.WriteTo(w)
+		}
+	}
+	return err
+}
--- a/vendor/github.com/emersion/go-imap/responses/idle.go
+++ b/vendor/github.com/emersion/go-imap/responses/idle.go
@@ -0,0 +1,38 @@
+package responses
+
+import (
+	"github.com/emersion/go-imap"
+)
+
+// An IDLE response.
+type Idle struct {
+	RepliesCh chan []byte
+	Stop      <-chan struct{}
+
+	gotContinuationReq bool
+}
+
+func (r *Idle) Replies() <-chan []byte {
+	return r.RepliesCh
+}
+
+func (r *Idle) stop() {
+	r.RepliesCh <- []byte("DONE\r\n")
+}
+
+func (r *Idle) Handle(resp imap.Resp) error {
+	// Wait for a continuation request
+	if _, ok := resp.(*imap.ContinuationReq); ok && !r.gotContinuationReq {
+		r.gotContinuationReq = true
+
+		// We got a continuation request, wait for r.Stop to be closed
+		go func() {
+			<-r.Stop
+			r.stop()
+		}()
+
+		return nil
+	}
+
+	return ErrUnhandled
+}
--- a/vendor/github.com/emersion/go-imap/responses/list.go
+++ b/vendor/github.com/emersion/go-imap/responses/list.go
@@ -0,0 +1,57 @@
+package responses
+
+import (
+	"github.com/emersion/go-imap"
+)
+
+const (
+	listName = "LIST"
+	lsubName = "LSUB"
+)
+
+// A LIST response.
+// If Subscribed is set to true, LSUB will be used instead.
+// See RFC 3501 section 7.2.2
+type List struct {
+	Mailboxes  chan *imap.MailboxInfo
+	Subscribed bool
+}
+
+func (r *List) Name() string {
+	if r.Subscribed {
+		return lsubName
+	} else {
+		return listName
+	}
+}
+
+func (r *List) Handle(resp imap.Resp) error {
+	name, fields, ok := imap.ParseNamedResp(resp)
+	if !ok || name != r.Name() {
+		return ErrUnhandled
+	}
+
+	mbox := &imap.MailboxInfo{}
+	if err := mbox.Parse(fields); err != nil {
+		return err
+	}
+
+	r.Mailboxes <- mbox
+	return nil
+}
+
+func (r *List) WriteTo(w *imap.Writer) error {
+	respName := r.Name()
+
+	for mbox := range r.Mailboxes {
+		fields := []interface{}{imap.RawString(respName)}
+		fields = append(fields, mbox.Format()...)
+
+		resp := imap.NewUntaggedResp(fields)
+		if err := resp.WriteTo(w); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/responses/responses.go
+++ b/vendor/github.com/emersion/go-imap/responses/responses.go
@@ -0,0 +1,35 @@
+// IMAP responses defined in RFC 3501.
+package responses
+
+import (
+	"errors"
+
+	"github.com/emersion/go-imap"
+)
+
+// ErrUnhandled is used when a response hasn't been handled.
+var ErrUnhandled = errors.New("imap: unhandled response")
+
+var errNotEnoughFields = errors.New("imap: not enough fields in response")
+
+// Handler handles responses.
+type Handler interface {
+	// Handle processes a response. If the response cannot be processed,
+	// ErrUnhandledResp must be returned.
+	Handle(resp imap.Resp) error
+}
+
+// HandlerFunc is a function that handles responses.
+type HandlerFunc func(resp imap.Resp) error
+
+// Handle implements Handler.
+func (f HandlerFunc) Handle(resp imap.Resp) error {
+	return f(resp)
+}
+
+// Replier is a Handler that needs to send raw data (for instance
+// AUTHENTICATE).
+type Replier interface {
+	Handler
+	Replies() <-chan []byte
+}
--- a/vendor/github.com/emersion/go-imap/responses/search.go
+++ b/vendor/github.com/emersion/go-imap/responses/search.go
@@ -0,0 +1,41 @@
+package responses
+
+import (
+	"github.com/emersion/go-imap"
+)
+
+const searchName = "SEARCH"
+
+// A SEARCH response.
+// See RFC 3501 section 7.2.5
+type Search struct {
+	Ids []uint32
+}
+
+func (r *Search) Handle(resp imap.Resp) error {
+	name, fields, ok := imap.ParseNamedResp(resp)
+	if !ok || name != searchName {
+		return ErrUnhandled
+	}
+
+	r.Ids = make([]uint32, len(fields))
+	for i, f := range fields {
+		if id, err := imap.ParseNumber(f); err != nil {
+			return err
+		} else {
+			r.Ids[i] = id
+		}
+	}
+
+	return nil
+}
+
+func (r *Search) WriteTo(w *imap.Writer) (err error) {
+	fields := []interface{}{imap.RawString(searchName)}
+	for _, id := range r.Ids {
+		fields = append(fields, id)
+	}
+
+	resp := imap.NewUntaggedResp(fields)
+	return resp.WriteTo(w)
+}
--- a/vendor/github.com/emersion/go-imap/responses/select.go
+++ b/vendor/github.com/emersion/go-imap/responses/select.go
@@ -0,0 +1,142 @@
+package responses
+
+import (
+	"fmt"
+
+	"github.com/emersion/go-imap"
+)
+
+// A SELECT response.
+type Select struct {
+	Mailbox *imap.MailboxStatus
+}
+
+func (r *Select) Handle(resp imap.Resp) error {
+	if r.Mailbox == nil {
+		r.Mailbox = &imap.MailboxStatus{Items: make(map[imap.StatusItem]interface{})}
+	}
+	mbox := r.Mailbox
+
+	switch resp := resp.(type) {
+	case *imap.DataResp:
+		name, fields, ok := imap.ParseNamedResp(resp)
+		if !ok || name != "FLAGS" {
+			return ErrUnhandled
+		} else if len(fields) < 1 {
+			return errNotEnoughFields
+		}
+
+		flags, _ := fields[0].([]interface{})
+		mbox.Flags, _ = imap.ParseStringList(flags)
+	case *imap.StatusResp:
+		if len(resp.Arguments) < 1 {
+			return ErrUnhandled
+		}
+
+		var item imap.StatusItem
+		switch resp.Code {
+		case "UNSEEN":
+			mbox.UnseenSeqNum, _ = imap.ParseNumber(resp.Arguments[0])
+		case "PERMANENTFLAGS":
+			flags, _ := resp.Arguments[0].([]interface{})
+			mbox.PermanentFlags, _ = imap.ParseStringList(flags)
+		case "UIDNEXT":
+			mbox.UidNext, _ = imap.ParseNumber(resp.Arguments[0])
+			item = imap.StatusUidNext
+		case "UIDVALIDITY":
+			mbox.UidValidity, _ = imap.ParseNumber(resp.Arguments[0])
+			item = imap.StatusUidValidity
+		default:
+			return ErrUnhandled
+		}
+
+		if item != "" {
+			mbox.ItemsLocker.Lock()
+			mbox.Items[item] = nil
+			mbox.ItemsLocker.Unlock()
+		}
+	default:
+		return ErrUnhandled
+	}
+	return nil
+}
+
+func (r *Select) WriteTo(w *imap.Writer) error {
+	mbox := r.Mailbox
+
+	if mbox.Flags != nil {
+		flags := make([]interface{}, len(mbox.Flags))
+		for i, f := range mbox.Flags {
+			flags[i] = imap.RawString(f)
+		}
+		res := imap.NewUntaggedResp([]interface{}{imap.RawString("FLAGS"), flags})
+		if err := res.WriteTo(w); err != nil {
+			return err
+		}
+	}
+
+	if mbox.PermanentFlags != nil {
+		flags := make([]interface{}, len(mbox.PermanentFlags))
+		for i, f := range mbox.PermanentFlags {
+			flags[i] = imap.RawString(f)
+		}
+		statusRes := &imap.StatusResp{
+			Type:      imap.StatusRespOk,
+			Code:      imap.CodePermanentFlags,
+			Arguments: []interface{}{flags},
+			Info:      "Flags permitted.",
+		}
+		if err := statusRes.WriteTo(w); err != nil {
+			return err
+		}
+	}
+
+	if mbox.UnseenSeqNum > 0 {
+		statusRes := &imap.StatusResp{
+			Type:      imap.StatusRespOk,
+			Code:      imap.CodeUnseen,
+			Arguments: []interface{}{mbox.UnseenSeqNum},
+			Info:      fmt.Sprintf("Message %d is first unseen", mbox.UnseenSeqNum),
+		}
+		if err := statusRes.WriteTo(w); err != nil {
+			return err
+		}
+	}
+
+	for k := range r.Mailbox.Items {
+		switch k {
+		case imap.StatusMessages:
+			res := imap.NewUntaggedResp([]interface{}{mbox.Messages, imap.RawString("EXISTS")})
+			if err := res.WriteTo(w); err != nil {
+				return err
+			}
+		case imap.StatusRecent:
+			res := imap.NewUntaggedResp([]interface{}{mbox.Recent, imap.RawString("RECENT")})
+			if err := res.WriteTo(w); err != nil {
+				return err
+			}
+		case imap.StatusUidNext:
+			statusRes := &imap.StatusResp{
+				Type:      imap.StatusRespOk,
+				Code:      imap.CodeUidNext,
+				Arguments: []interface{}{mbox.UidNext},
+				Info:      "Predicted next UID",
+			}
+			if err := statusRes.WriteTo(w); err != nil {
+				return err
+			}
+		case imap.StatusUidValidity:
+			statusRes := &imap.StatusResp{
+				Type:      imap.StatusRespOk,
+				Code:      imap.CodeUidValidity,
+				Arguments: []interface{}{mbox.UidValidity},
+				Info:      "UIDs valid",
+			}
+			if err := statusRes.WriteTo(w); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
--- a/vendor/github.com/emersion/go-imap/responses/status.go
+++ b/vendor/github.com/emersion/go-imap/responses/status.go
@@ -0,0 +1,53 @@
+package responses
+
+import (
+	"errors"
+
+	"github.com/emersion/go-imap"
+	"github.com/emersion/go-imap/utf7"
+)
+
+const statusName = "STATUS"
+
+// A STATUS response.
+// See RFC 3501 section 7.2.4
+type Status struct {
+	Mailbox *imap.MailboxStatus
+}
+
+func (r *Status) Handle(resp imap.Resp) error {
+	if r.Mailbox == nil {
+		r.Mailbox = &imap.MailboxStatus{}
+	}
+	mbox := r.Mailbox
+
+	name, fields, ok := imap.ParseNamedResp(resp)
+	if !ok || name != statusName {
+		return ErrUnhandled
+	} else if len(fields) < 2 {
+		return errNotEnoughFields
+	}
+
+	if name, err := imap.ParseString(fields[0]); err != nil {
+		return err
+	} else if name, err := utf7.Encoding.NewDecoder().String(name); err != nil {
+		return err
+	} else {
+		mbox.Name = imap.CanonicalMailboxName(name)
+	}
+
+	var items []interface{}
+	if items, ok = fields[1].([]interface{}); !ok {
+		return errors.New("STATUS response expects a list as second argument")
+	}
+
+	mbox.Items = nil
+	return mbox.Parse(items)
+}
+
+func (r *Status) WriteTo(w *imap.Writer) error {
+	mbox := r.Mailbox
+	name, _ := utf7.Encoding.NewEncoder().String(mbox.Name)
+	fields := []interface{}{imap.RawString(statusName), imap.FormatMailboxName(name), mbox.Format()}
+	return imap.NewUntaggedResp(fields).WriteTo(w)
+}
--- a/vendor/github.com/emersion/go-imap/search.go
+++ b/vendor/github.com/emersion/go-imap/search.go
@@ -0,0 +1,371 @@
+package imap
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"net/textproto"
+	"strings"
+	"time"
+)
+
+func maybeString(mystery interface{}) string {
+	if s, ok := mystery.(string); ok {
+		return s
+	}
+	return ""
+}
+
+func convertField(f interface{}, charsetReader func(io.Reader) io.Reader) string {
+	// An IMAP string contains only 7-bit data, no need to decode it
+	if s, ok := f.(string); ok {
+		return s
+	}
+
+	// If no charset is provided, getting directly the string is faster
+	if charsetReader == nil {
+		if stringer, ok := f.(fmt.Stringer); ok {
+			return stringer.String()
+		}
+	}
+
+	// Not a string, it must be a literal
+	l, ok := f.(Literal)
+	if !ok {
+		return ""
+	}
+
+	var r io.Reader = l
+	if charsetReader != nil {
+		if dec := charsetReader(r); dec != nil {
+			r = dec
+		}
+	}
+
+	b := make([]byte, l.Len())
+	if _, err := io.ReadFull(r, b); err != nil {
+		return ""
+	}
+	return string(b)
+}
+
+func popSearchField(fields []interface{}) (interface{}, []interface{}, error) {
+	if len(fields) == 0 {
+		return nil, nil, errors.New("imap: no enough fields for search key")
+	}
+	return fields[0], fields[1:], nil
+}
+
+// SearchCriteria is a search criteria. A message matches the criteria if and
+// only if it matches each one of its fields.
+type SearchCriteria struct {
+	SeqNum *SeqSet // Sequence number is in sequence set
+	Uid    *SeqSet // UID is in sequence set
+
+	// Time and timezone are ignored
+	Since      time.Time // Internal date is since this date
+	Before     time.Time // Internal date is before this date
+	SentSince  time.Time // Date header field is since this date
+	SentBefore time.Time // Date header field is before this date
+
+	Header textproto.MIMEHeader // Each header field value is present
+	Body   []string             // Each string is in the body
+	Text   []string             // Each string is in the text (header + body)
+
+	WithFlags    []string // Each flag is present
+	WithoutFlags []string // Each flag is not present
+
+	Larger  uint32 // Size is larger than this number
+	Smaller uint32 // Size is smaller than this number
+
+	Not []*SearchCriteria    // Each criteria doesn't match
+	Or  [][2]*SearchCriteria // Each criteria pair has at least one match of two
+}
+
+// NewSearchCriteria creates a new search criteria.
+func NewSearchCriteria() *SearchCriteria {
+	return &SearchCriteria{Header: make(textproto.MIMEHeader)}
+}
+
+func (c *SearchCriteria) parseField(fields []interface{}, charsetReader func(io.Reader) io.Reader) ([]interface{}, error) {
+	if len(fields) == 0 {
+		return nil, nil
+	}
+
+	f := fields[0]
+	fields = fields[1:]
+
+	if subfields, ok := f.([]interface{}); ok {
+		return fields, c.ParseWithCharset(subfields, charsetReader)
+	}
+
+	key, ok := f.(string)
+	if !ok {
+		return nil, fmt.Errorf("imap: invalid search criteria field type: %T", f)
+	}
+	key = strings.ToUpper(key)
+
+	var err error
+	switch key {
+	case "ALL":
+		// Nothing to do
+	case "ANSWERED", "DELETED", "DRAFT", "FLAGGED", "RECENT", "SEEN":
+		c.WithFlags = append(c.WithFlags, CanonicalFlag("\\"+key))
+	case "BCC", "CC", "FROM", "SUBJECT", "TO":
+		if f, fields, err = popSearchField(fields); err != nil {
+			return nil, err
+		}
+		if c.Header == nil {
+			c.Header = make(textproto.MIMEHeader)
+		}
+		c.Header.Add(key, convertField(f, charsetReader))
+	case "BEFORE":
+		if f, fields, err = popSearchField(fields); err != nil {
+			return nil, err
+		} else if t, err := time.Parse(DateLayout, maybeString(f)); err != nil {
+			return nil, err
+		} else if c.Before.IsZero() || t.Before(c.Before) {
+			c.Before = t
+		}
+	case "BODY":
+		if f, fields, err = popSearchField(fields); err != nil {
+			return nil, err
+		} else {
+			c.Body = append(c.Body, convertField(f, charsetReader))
+		}
+	case "HEADER":
+		var f1, f2 interface{}
+		if f1, fields, err = popSearchField(fields); err != nil {
+			return nil, err
+		} else if f2, fields, err = popSearchField(fields); err != nil {
+			return nil, err
+		} else {
+			if c.Header == nil {
+				c.Header = make(textproto.MIMEHeader)
+			}
+			c.Header.Add(maybeString(f1), convertField(f2, charsetReader))
+		}
+	case "KEYWORD":
+		if f, fields, err = popSearchField(fields); err != nil {
+			return nil, err
+		} else {
+			c.WithFlags = append(c.WithFlags, CanonicalFlag(maybeString(f)))
+		}
+	case "LARGER":
+		if f, fields, err = popSearchField(fields); err != nil {
+			return nil, err
+		} else if n, err := ParseNumber(f); err != nil {
+			return nil, err
+		} else if c.Larger == 0 || n > c.Larger {
+			c.Larger = n
+		}
+	case "NEW":
+		c.WithFlags = append(c.WithFlags, RecentFlag)
+		c.WithoutFlags = append(c.WithoutFlags, SeenFlag)
+	case "NOT":
+		not := new(SearchCriteria)
+		if fields, err = not.parseField(fields, charsetReader); err != nil {
+			return nil, err
+		}
+		c.Not = append(c.Not, not)
+	case "OLD":
+		c.WithoutFlags = append(c.WithoutFlags, RecentFlag)
+	case "ON":
+		if f, fields, err = popSearchField(fields); err != nil {
+			return nil, err
+		} else if t, err := time.Parse(DateLayout, maybeString(f)); err != nil {
+			return nil, err
+		} else {
+			c.Since = t
+			c.Before = t.Add(24 * time.Hour)
+		}
+	case "OR":
+		c1, c2 := new(SearchCriteria), new(SearchCriteria)
+		if fields, err = c1.parseField(fields, charsetReader); err != nil {
+			return nil, err
+		} else if fields, err = c2.parseField(fields, charsetReader); err != nil {
+			return nil, err
+		}
+		c.Or = append(c.Or, [2]*SearchCriteria{c1, c2})
+	case "SENTBEFORE":
+		if f, fields, err = popSearchField(fields); err != nil {
+			return nil, err
+		} else if t, err := time.Parse(DateLayout, maybeString(f)); err != nil {
+			return nil, err
+		} else if c.SentBefore.IsZero() || t.Before(c.SentBefore) {
+			c.SentBefore = t
+		}
+	case "SENTON":
+		if f, fields, err = popSearchField(fields); err != nil {
+			return nil, err
+		} else if t, err := time.Parse(DateLayout, maybeString(f)); err != nil {
+			return nil, err
+		} else {
+			c.SentSince = t
+			c.SentBefore = t.Add(24 * time.Hour)
+		}
+	case "SENTSINCE":
+		if f, fields, err = popSearchField(fields); err != nil {
+			return nil, err
+		} else if t, err := time.Parse(DateLayout, maybeString(f)); err != nil {
+			return nil, err
+		} else if c.SentSince.IsZero() || t.After(c.SentSince) {
+			c.SentSince = t
+		}
+	case "SINCE":
+		if f, fields, err = popSearchField(fields); err != nil {
+			return nil, err
+		} else if t, err := time.Parse(DateLayout, maybeString(f)); err != nil {
+			return nil, err
+		} else if c.Since.IsZero() || t.After(c.Since) {
+			c.Since = t
+		}
+	case "SMALLER":
+		if f, fields, err = popSearchField(fields); err != nil {
+			return nil, err
+		} else if n, err := ParseNumber(f); err != nil {
+			return nil, err
+		} else if c.Smaller == 0 || n < c.Smaller {
+			c.Smaller = n
+		}
+	case "TEXT":
+		if f, fields, err = popSearchField(fields); err != nil {
+			return nil, err
+		} else {
+			c.Text = append(c.Text, convertField(f, charsetReader))
+		}
+	case "UID":
+		if f, fields, err = popSearchField(fields); err != nil {
+			return nil, err
+		} else if c.Uid, err = ParseSeqSet(maybeString(f)); err != nil {
+			return nil, err
+		}
+	case "UNANSWERED", "UNDELETED", "UNDRAFT", "UNFLAGGED", "UNSEEN":
+		unflag := strings.TrimPrefix(key, "UN")
+		c.WithoutFlags = append(c.WithoutFlags, CanonicalFlag("\\"+unflag))
+	case "UNKEYWORD":
+		if f, fields, err = popSearchField(fields); err != nil {
+			return nil, err
+		} else {
+			c.WithoutFlags = append(c.WithoutFlags, CanonicalFlag(maybeString(f)))
+		}
+	default: // Try to parse a sequence set
+		if c.SeqNum, err = ParseSeqSet(key); err != nil {
+			return nil, err
+		}
+	}
+
+	return fields, nil
+}
+
+// ParseWithCharset parses a search criteria from the provided fields.
+// charsetReader is an optional function that converts from the fields charset
+// to UTF-8.
+func (c *SearchCriteria) ParseWithCharset(fields []interface{}, charsetReader func(io.Reader) io.Reader) error {
+	for len(fields) > 0 {
+		var err error
+		if fields, err = c.parseField(fields, charsetReader); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Format formats search criteria to fields. UTF-8 is used.
+func (c *SearchCriteria) Format() []interface{} {
+	var fields []interface{}
+
+	if c.SeqNum != nil {
+		fields = append(fields, c.SeqNum)
+	}
+	if c.Uid != nil {
+		fields = append(fields, RawString("UID"), c.Uid)
+	}
+
+	if !c.Since.IsZero() && !c.Before.IsZero() && c.Before.Sub(c.Since) == 24*time.Hour {
+		fields = append(fields, RawString("ON"), searchDate(c.Since))
+	} else {
+		if !c.Since.IsZero() {
+			fields = append(fields, RawString("SINCE"), searchDate(c.Since))
+		}
+		if !c.Before.IsZero() {
+			fields = append(fields, RawString("BEFORE"), searchDate(c.Before))
+		}
+	}
+	if !c.SentSince.IsZero() && !c.SentBefore.IsZero() && c.SentBefore.Sub(c.SentSince) == 24*time.Hour {
+		fields = append(fields, RawString("SENTON"), searchDate(c.SentSince))
+	} else {
+		if !c.SentSince.IsZero() {
+			fields = append(fields, RawString("SENTSINCE"), searchDate(c.SentSince))
+		}
+		if !c.SentBefore.IsZero() {
+			fields = append(fields, RawString("SENTBEFORE"), searchDate(c.SentBefore))
+		}
+	}
+
+	for key, values := range c.Header {
+		var prefields []interface{}
+		switch key {
+		case "Bcc", "Cc", "From", "Subject", "To":
+			prefields = []interface{}{RawString(strings.ToUpper(key))}
+		default:
+			prefields = []interface{}{RawString("HEADER"), key}
+		}
+		for _, value := range values {
+			fields = append(fields, prefields...)
+			fields = append(fields, value)
+		}
+	}
+
+	for _, value := range c.Body {
+		fields = append(fields, RawString("BODY"), value)
+	}
+	for _, value := range c.Text {
+		fields = append(fields, RawString("TEXT"), value)
+	}
+
+	for _, flag := range c.WithFlags {
+		var subfields []interface{}
+		switch flag {
+		case AnsweredFlag, DeletedFlag, DraftFlag, FlaggedFlag, RecentFlag, SeenFlag:
+			subfields = []interface{}{RawString(strings.ToUpper(strings.TrimPrefix(flag, "\\")))}
+		default:
+			subfields = []interface{}{RawString("KEYWORD"), RawString(flag)}
+		}
+		fields = append(fields, subfields...)
+	}
+	for _, flag := range c.WithoutFlags {
+		var subfields []interface{}
+		switch flag {
+		case AnsweredFlag, DeletedFlag, DraftFlag, FlaggedFlag, SeenFlag:
+			subfields = []interface{}{RawString("UN" + strings.ToUpper(strings.TrimPrefix(flag, "\\")))}
+		case RecentFlag:
+			subfields = []interface{}{RawString("OLD")}
+		default:
+			subfields = []interface{}{RawString("UNKEYWORD"), RawString(flag)}
+		}
+		fields = append(fields, subfields...)
+	}
+
+	if c.Larger > 0 {
+		fields = append(fields, RawString("LARGER"), c.Larger)
+	}
+	if c.Smaller > 0 {
+		fields = append(fields, RawString("SMALLER"), c.Smaller)
+	}
+
+	for _, not := range c.Not {
+		fields = append(fields, RawString("NOT"), not.Format())
+	}
+
+	for _, or := range c.Or {
+		fields = append(fields, RawString("OR"), or[0].Format(), or[1].Format())
+	}
+
+	// Not a single criteria given, add ALL criteria as fallback
+	if len(fields) == 0 {
+		fields = append(fields, RawString("ALL"))
+	}
+
+	return fields
+}
--- a/vendor/github.com/emersion/go-imap/seqset.go
+++ b/vendor/github.com/emersion/go-imap/seqset.go
@@ -0,0 +1,289 @@
+package imap
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// ErrBadSeqSet is used to report problems with the format of a sequence set
+// value.
+type ErrBadSeqSet string
+
+func (err ErrBadSeqSet) Error() string {
+	return fmt.Sprintf("imap: bad sequence set value %q", string(err))
+}
+
+// Seq represents a single seq-number or seq-range value (RFC 3501 ABNF). Values
+// may be static (e.g. "1", "2:4") or dynamic (e.g. "*", "1:*"). A seq-number is
+// represented by setting Start = Stop. Zero is used to represent "*", which is
+// safe because seq-number uses nz-number rule. The order of values is always
+// Start <= Stop, except when representing "n:*", where Start = n and Stop = 0.
+type Seq struct {
+	Start, Stop uint32
+}
+
+// parseSeqNumber parses a single seq-number value (non-zero uint32 or "*").
+func parseSeqNumber(v string) (uint32, error) {
+	if n, err := strconv.ParseUint(v, 10, 32); err == nil && v[0] != '0' {
+		return uint32(n), nil
+	} else if v == "*" {
+		return 0, nil
+	}
+	return 0, ErrBadSeqSet(v)
+}
+
+// parseSeq creates a new seq instance by parsing strings in the format "n" or
+// "n:m", where n and/or m may be "*". An error is returned for invalid values.
+func parseSeq(v string) (s Seq, err error) {
+	if sep := strings.IndexRune(v, ':'); sep < 0 {
+		s.Start, err = parseSeqNumber(v)
+		s.Stop = s.Start
+		return
+	} else if s.Start, err = parseSeqNumber(v[:sep]); err == nil {
+		if s.Stop, err = parseSeqNumber(v[sep+1:]); err == nil {
+			if (s.Stop < s.Start && s.Stop != 0) || s.Start == 0 {
+				s.Start, s.Stop = s.Stop, s.Start
+			}
+			return
+		}
+	}
+	return s, ErrBadSeqSet(v)
+}
+
+// Contains returns true if the seq-number q is contained in sequence value s.
+// The dynamic value "*" contains only other "*" values, the dynamic range "n:*"
+// contains "*" and all numbers >= n.
+func (s Seq) Contains(q uint32) bool {
+	if q == 0 {
+		return s.Stop == 0 // "*" is contained only in "*" and "n:*"
+	}
+	return s.Start != 0 && s.Start <= q && (q <= s.Stop || s.Stop == 0)
+}
+
+// Less returns true if s precedes and does not contain seq-number q.
+func (s Seq) Less(q uint32) bool {
+	return (s.Stop < q || q == 0) && s.Stop != 0
+}
+
+// Merge combines sequence values s and t into a single union if the two
+// intersect or one is a superset of the other. The order of s and t does not
+// matter. If the values cannot be merged, s is returned unmodified and ok is
+// set to false.
+func (s Seq) Merge(t Seq) (union Seq, ok bool) {
+	if union = s; s == t {
+		ok = true
+		return
+	}
+	if s.Start != 0 && t.Start != 0 {
+		// s and t are any combination of "n", "n:m", or "n:*"
+		if s.Start > t.Start {
+			s, t = t, s
+		}
+		// s starts at or before t, check where it ends
+		if (s.Stop >= t.Stop && t.Stop != 0) || s.Stop == 0 {
+			return s, true // s is a superset of t
+		}
+		// s is "n" or "n:m", if m == ^uint32(0) then t is "n:*"
+		if s.Stop+1 >= t.Start || s.Stop == ^uint32(0) {
+			return Seq{s.Start, t.Stop}, true // s intersects or touches t
+		}
+		return
+	}
+	// exactly one of s and t is "*"
+	if s.Start == 0 {
+		if t.Stop == 0 {
+			return t, true // s is "*", t is "n:*"
+		}
+	} else if s.Stop == 0 {
+		return s, true // s is "n:*", t is "*"
+	}
+	return
+}
+
+// String returns sequence value s as a seq-number or seq-range string.
+func (s Seq) String() string {
+	if s.Start == s.Stop {
+		if s.Start == 0 {
+			return "*"
+		}
+		return strconv.FormatUint(uint64(s.Start), 10)
+	}
+	b := strconv.AppendUint(make([]byte, 0, 24), uint64(s.Start), 10)
+	if s.Stop == 0 {
+		return string(append(b, ':', '*'))
+	}
+	return string(strconv.AppendUint(append(b, ':'), uint64(s.Stop), 10))
+}
+
+// SeqSet is used to represent a set of message sequence numbers or UIDs (see
+// sequence-set ABNF rule). The zero value is an empty set.
+type SeqSet struct {
+	Set []Seq
+}
+
+// ParseSeqSet returns a new SeqSet instance after parsing the set string.
+func ParseSeqSet(set string) (s *SeqSet, err error) {
+	s = new(SeqSet)
+	return s, s.Add(set)
+}
+
+// Add inserts new sequence values into the set. The string format is described
+// by RFC 3501 sequence-set ABNF rule. If an error is encountered, all values
+// inserted successfully prior to the error remain in the set.
+func (s *SeqSet) Add(set string) error {
+	for _, sv := range strings.Split(set, ",") {
+		v, err := parseSeq(sv)
+		if err != nil {
+			return err
+		}
+		s.insert(v)
+	}
+	return nil
+}
+
+// AddNum inserts new sequence numbers into the set. The value 0 represents "*".
+func (s *SeqSet) AddNum(q ...uint32) {
+	for _, v := range q {
+		s.insert(Seq{v, v})
+	}
+}
+
+// AddRange inserts a new sequence range into the set.
+func (s *SeqSet) AddRange(Start, Stop uint32) {
+	if (Stop < Start && Stop != 0) || Start == 0 {
+		s.insert(Seq{Stop, Start})
+	} else {
+		s.insert(Seq{Start, Stop})
+	}
+}
+
+// AddSet inserts all values from t into s.
+func (s *SeqSet) AddSet(t *SeqSet) {
+	for _, v := range t.Set {
+		s.insert(v)
+	}
+}
+
+// Clear removes all values from the set.
+func (s *SeqSet) Clear() {
+	s.Set = s.Set[:0]
+}
+
+// Empty returns true if the sequence set does not contain any values.
+func (s SeqSet) Empty() bool {
+	return len(s.Set) == 0
+}
+
+// Dynamic returns true if the set contains "*" or "n:*" values.
+func (s SeqSet) Dynamic() bool {
+	return len(s.Set) > 0 && s.Set[len(s.Set)-1].Stop == 0
+}
+
+// Contains returns true if the non-zero sequence number or UID q is contained
+// in the set. The dynamic range "n:*" contains all q >= n. It is the caller's
+// responsibility to handle the special case where q is the maximum UID in the
+// mailbox and q < n (i.e. the set cannot match UIDs against "*:n" or "*" since
+// it doesn't know what the maximum value is).
+func (s SeqSet) Contains(q uint32) bool {
+	if _, ok := s.search(q); ok {
+		return q != 0
+	}
+	return false
+}
+
+// String returns a sorted representation of all contained sequence values.
+func (s SeqSet) String() string {
+	if len(s.Set) == 0 {
+		return ""
+	}
+	b := make([]byte, 0, 64)
+	for _, v := range s.Set {
+		b = append(b, ',')
+		if v.Start == 0 {
+			b = append(b, '*')
+			continue
+		}
+		b = strconv.AppendUint(b, uint64(v.Start), 10)
+		if v.Start != v.Stop {
+			if v.Stop == 0 {
+				b = append(b, ':', '*')
+				continue
+			}
+			b = strconv.AppendUint(append(b, ':'), uint64(v.Stop), 10)
+		}
+	}
+	return string(b[1:])
+}
+
+// insert adds sequence value v to the set.
+func (s *SeqSet) insert(v Seq) {
+	i, _ := s.search(v.Start)
+	merged := false
+	if i > 0 {
+		// try merging with the preceding entry (e.g. "1,4".insert(2), i == 1)
+		s.Set[i-1], merged = s.Set[i-1].Merge(v)
+	}
+	if i == len(s.Set) {
+		// v was either merged with the last entry or needs to be appended
+		if !merged {
+			s.insertAt(i, v)
+		}
+		return
+	} else if merged {
+		i--
+	} else if s.Set[i], merged = s.Set[i].Merge(v); !merged {
+		s.insertAt(i, v) // insert in the middle (e.g. "1,5".insert(3), i == 1)
+		return
+	}
+	// v was merged with s.Set[i], continue trying to merge until the end
+	for j := i + 1; j < len(s.Set); j++ {
+		if s.Set[i], merged = s.Set[i].Merge(s.Set[j]); !merged {
+			if j > i+1 {
+				// cut out all entries between i and j that were merged
+				s.Set = append(s.Set[:i+1], s.Set[j:]...)
+			}
+			return
+		}
+	}
+	// everything after s.Set[i] was merged
+	s.Set = s.Set[:i+1]
+}
+
+// insertAt inserts a new sequence value v at index i, resizing s.Set as needed.
+func (s *SeqSet) insertAt(i int, v Seq) {
+	if n := len(s.Set); i == n {
+		// insert at the end
+		s.Set = append(s.Set, v)
+		return
+	} else if n < cap(s.Set) {
+		// enough space, shift everything at and after i to the right
+		s.Set = s.Set[:n+1]
+		copy(s.Set[i+1:], s.Set[i:])
+	} else {
+		// allocate new slice and copy everything, n is at least 1
+		set := make([]Seq, n+1, n*2)
+		copy(set, s.Set[:i])
+		copy(set[i+1:], s.Set[i:])
+		s.Set = set
+	}
+	s.Set[i] = v
+}
+
+// search attempts to find the index of the sequence set value that contains q.
+// If no values contain q, the returned index is the position where q should be
+// inserted and ok is set to false.
+func (s SeqSet) search(q uint32) (i int, ok bool) {
+	min, max := 0, len(s.Set)-1
+	for min < max {
+		if mid := (min + max) >> 1; s.Set[mid].Less(q) {
+			min = mid + 1
+		} else {
+			max = mid
+		}
+	}
+	if max < 0 || s.Set[min].Less(q) {
+		return len(s.Set), false // q is the new largest value
+	}
+	return min, s.Set[min].Contains(q)
+}
--- a/vendor/github.com/emersion/go-imap/status.go
+++ b/vendor/github.com/emersion/go-imap/status.go
@@ -0,0 +1,136 @@
+package imap
+
+import (
+	"errors"
+)
+
+// A status response type.
+type StatusRespType string
+
+// Status response types defined in RFC 3501 section 7.1.
+const (
+	// The OK response indicates an information message from the server.  When
+	// tagged, it indicates successful completion of the associated command.
+	// The untagged form indicates an information-only message.
+	StatusRespOk StatusRespType = "OK"
+
+	// The NO response indicates an operational error message from the
+	// server.  When tagged, it indicates unsuccessful completion of the
+	// associated command.  The untagged form indicates a warning; the
+	// command can still complete successfully.
+	StatusRespNo StatusRespType = "NO"
+
+	// The BAD response indicates an error message from the server.  When
+	// tagged, it reports a protocol-level error in the client's command;
+	// the tag indicates the command that caused the error.  The untagged
+	// form indicates a protocol-level error for which the associated
+	// command can not be determined; it can also indicate an internal
+	// server failure.
+	StatusRespBad StatusRespType = "BAD"
+
+	// The PREAUTH response is always untagged, and is one of three
+	// possible greetings at connection startup.  It indicates that the
+	// connection has already been authenticated by external means; thus
+	// no LOGIN command is needed.
+	StatusRespPreauth StatusRespType = "PREAUTH"
+
+	// The BYE response is always untagged, and indicates that the server
+	// is about to close the connection.
+	StatusRespBye StatusRespType = "BYE"
+)
+
+type StatusRespCode string
+
+// Status response codes defined in RFC 3501 section 7.1.
+const (
+	CodeAlert          StatusRespCode = "ALERT"
+	CodeBadCharset     StatusRespCode = "BADCHARSET"
+	CodeCapability     StatusRespCode = "CAPABILITY"
+	CodeParse          StatusRespCode = "PARSE"
+	CodePermanentFlags StatusRespCode = "PERMANENTFLAGS"
+	CodeReadOnly       StatusRespCode = "READ-ONLY"
+	CodeReadWrite      StatusRespCode = "READ-WRITE"
+	CodeTryCreate      StatusRespCode = "TRYCREATE"
+	CodeUidNext        StatusRespCode = "UIDNEXT"
+	CodeUidValidity    StatusRespCode = "UIDVALIDITY"
+	CodeUnseen         StatusRespCode = "UNSEEN"
+)
+
+// A status response.
+// See RFC 3501 section 7.1
+type StatusResp struct {
+	// The response tag. If empty, it defaults to *.
+	Tag string
+	// The status type.
+	Type StatusRespType
+	// The status code.
+	// See https://www.iana.org/assignments/imap-response-codes/imap-response-codes.xhtml
+	Code StatusRespCode
+	// Arguments provided with the status code.
+	Arguments []interface{}
+	// The status info.
+	Info string
+}
+
+func (r *StatusResp) resp() {}
+
+// If this status is NO or BAD, returns an error with the status info.
+// Otherwise, returns nil.
+func (r *StatusResp) Err() error {
+	if r == nil {
+		// No status response, connection closed before we get one
+		return errors.New("imap: connection closed during command execution")
+	}
+
+	if r.Type == StatusRespNo || r.Type == StatusRespBad {
+		return errors.New(r.Info)
+	}
+	return nil
+}
+
+func (r *StatusResp) WriteTo(w *Writer) error {
+	tag := RawString(r.Tag)
+	if tag == "" {
+		tag = "*"
+	}
+
+	if err := w.writeFields([]interface{}{RawString(tag), RawString(r.Type)}); err != nil {
+		return err
+	}
+
+	if err := w.writeString(string(sp)); err != nil {
+		return err
+	}
+
+	if r.Code != "" {
+		if err := w.writeRespCode(r.Code, r.Arguments); err != nil {
+			return err
+		}
+
+		if err := w.writeString(string(sp)); err != nil {
+			return err
+		}
+	}
+
+	if err := w.writeString(r.Info); err != nil {
+		return err
+	}
+
+	return w.writeCrlf()
+}
+
+// ErrStatusResp can be returned by a server.Handler to replace the default status
+// response. The response tag must be empty.
+//
+// To suppress default response, Resp should be set to nil.
+type ErrStatusResp struct {
+	// Response to send instead of default.
+	Resp *StatusResp
+}
+
+func (err *ErrStatusResp) Error() string {
+	if err.Resp == nil {
+		return "imap: suppressed response"
+	}
+	return err.Resp.Info
+}
--- a/vendor/github.com/emersion/go-imap/utf7/decoder.go
+++ b/vendor/github.com/emersion/go-imap/utf7/decoder.go
@@ -0,0 +1,149 @@
+package utf7
+
+import (
+	"errors"
+	"unicode/utf16"
+	"unicode/utf8"
+
+	"golang.org/x/text/transform"
+)
+
+// ErrInvalidUTF7 means that a transformer encountered invalid UTF-7.
+var ErrInvalidUTF7 = errors.New("utf7: invalid UTF-7")
+
+type decoder struct {
+	ascii bool
+}
+
+func (d *decoder) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	for i := 0; i < len(src); i++ {
+		ch := src[i]
+
+		if ch < min || ch > max { // Illegal code point in ASCII mode
+			err = ErrInvalidUTF7
+			return
+		}
+
+		if ch != '&' {
+			if nDst+1 > len(dst) {
+				err = transform.ErrShortDst
+				return
+			}
+
+			nSrc++
+
+			dst[nDst] = ch
+			nDst++
+
+			d.ascii = true
+			continue
+		}
+
+		// Find the end of the Base64 or "&-" segment
+		start := i + 1
+		for i++; i < len(src) && src[i] != '-'; i++ {
+			if src[i] == '\r' || src[i] == '\n' { // base64 package ignores CR and LF
+				err = ErrInvalidUTF7
+				return
+			}
+		}
+
+		if i == len(src) { // Implicit shift ("&...")
+			if atEOF {
+				err = ErrInvalidUTF7
+			} else {
+				err = transform.ErrShortSrc
+			}
+			return
+		}
+
+		var b []byte
+		if i == start { // Escape sequence "&-"
+			b = []byte{'&'}
+			d.ascii = true
+		} else { // Control or non-ASCII code points in base64
+			if !d.ascii { // Null shift ("&...-&...-")
+				err = ErrInvalidUTF7
+				return
+			}
+
+			b = decode(src[start:i])
+			d.ascii = false
+		}
+
+		if len(b) == 0 { // Bad encoding
+			err = ErrInvalidUTF7
+			return
+		}
+
+		if nDst+len(b) > len(dst) {
+			d.ascii = true
+			err = transform.ErrShortDst
+			return
+		}
+
+		nSrc = i + 1
+
+		for _, ch := range b {
+			dst[nDst] = ch
+			nDst++
+		}
+	}
+
+	if atEOF {
+		d.ascii = true
+	}
+
+	return
+}
+
+func (d *decoder) Reset() {
+	d.ascii = true
+}
+
+// Extracts UTF-16-BE bytes from base64 data and converts them to UTF-8.
+// A nil slice is returned if the encoding is invalid.
+func decode(b64 []byte) []byte {
+	var b []byte
+
+	// Allocate a single block of memory large enough to store the Base64 data
+	// (if padding is required), UTF-16-BE bytes, and decoded UTF-8 bytes.
+	// Since a 2-byte UTF-16 sequence may expand into a 3-byte UTF-8 sequence,
+	// double the space allocation for UTF-8.
+	if n := len(b64); b64[n-1] == '=' {
+		return nil
+	} else if n&3 == 0 {
+		b = make([]byte, b64Enc.DecodedLen(n)*3)
+	} else {
+		n += 4 - n&3
+		b = make([]byte, n+b64Enc.DecodedLen(n)*3)
+		copy(b[copy(b, b64):n], []byte("=="))
+		b64, b = b[:n], b[n:]
+	}
+
+	// Decode Base64 into the first 1/3rd of b
+	n, err := b64Enc.Decode(b, b64)
+	if err != nil || n&1 == 1 {
+		return nil
+	}
+
+	// Decode UTF-16-BE into the remaining 2/3rds of b
+	b, s := b[:n], b[n:]
+	j := 0
+	for i := 0; i < n; i += 2 {
+		r := rune(b[i])<<8 | rune(b[i+1])
+		if utf16.IsSurrogate(r) {
+			if i += 2; i == n {
+				return nil
+			}
+			r2 := rune(b[i])<<8 | rune(b[i+1])
+			if r = utf16.DecodeRune(r, r2); r == repl {
+				return nil
+			}
+		} else if min <= r && r <= max {
+			return nil
+		}
+		j += utf8.EncodeRune(s[j:], r)
+	}
+	return s[:j]
+}
--- a/vendor/github.com/emersion/go-imap/utf7/encoder.go
+++ b/vendor/github.com/emersion/go-imap/utf7/encoder.go
@@ -0,0 +1,91 @@
+package utf7
+
+import (
+	"unicode/utf16"
+	"unicode/utf8"
+
+	"golang.org/x/text/transform"
+)
+
+type encoder struct{}
+
+func (e *encoder) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	for i := 0; i < len(src); {
+		ch := src[i]
+
+		var b []byte
+		if min <= ch && ch <= max {
+			b = []byte{ch}
+			if ch == '&' {
+				b = append(b, '-')
+			}
+
+			i++
+		} else {
+			start := i
+
+			// Find the next printable ASCII code point
+			i++
+			for i < len(src) && (src[i] < min || src[i] > max) {
+				i++
+			}
+
+			if !atEOF && i == len(src) {
+				err = transform.ErrShortSrc
+				return
+			}
+
+			b = encode(src[start:i])
+		}
+
+		if nDst+len(b) > len(dst) {
+			err = transform.ErrShortDst
+			return
+		}
+
+		nSrc = i
+
+		for _, ch := range b {
+			dst[nDst] = ch
+			nDst++
+		}
+	}
+
+	return
+}
+
+func (e *encoder) Reset() {}
+
+// Converts string s from UTF-8 to UTF-16-BE, encodes the result as base64,
+// removes the padding, and adds UTF-7 shifts.
+func encode(s []byte) []byte {
+	// len(s) is sufficient for UTF-8 to UTF-16 conversion if there are no
+	// control code points (see table below).
+	b := make([]byte, 0, len(s)+4)
+	for len(s) > 0 {
+		r, size := utf8.DecodeRune(s)
+		if r > utf8.MaxRune {
+			r, size = utf8.RuneError, 1 // Bug fix (issue 3785)
+		}
+		s = s[size:]
+		if r1, r2 := utf16.EncodeRune(r); r1 != repl {
+			b = append(b, byte(r1>>8), byte(r1))
+			r = r2
+		}
+		b = append(b, byte(r>>8), byte(r))
+	}
+
+	// Encode as base64
+	n := b64Enc.EncodedLen(len(b)) + 2
+	b64 := make([]byte, n)
+	b64Enc.Encode(b64[1:], b)
+
+	// Strip padding
+	n -= 2 - (len(b)+2)%3
+	b64 = b64[:n]
+
+	// Add UTF-7 shifts
+	b64[0] = '&'
+	b64[n-1] = '-'
+	return b64
+}
--- a/vendor/github.com/emersion/go-imap/utf7/utf7.go
+++ b/vendor/github.com/emersion/go-imap/utf7/utf7.go
@@ -0,0 +1,34 @@
+// Package utf7 implements modified UTF-7 encoding defined in RFC 3501 section 5.1.3
+package utf7
+
+import (
+	"encoding/base64"
+
+	"golang.org/x/text/encoding"
+)
+
+const (
+	min = 0x20 // Minimum self-representing UTF-7 value
+	max = 0x7E // Maximum self-representing UTF-7 value
+
+	repl = '\uFFFD' // Unicode replacement code point
+)
+
+var b64Enc = base64.NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+,")
+
+type enc struct{}
+
+func (e enc) NewDecoder() *encoding.Decoder {
+	return &encoding.Decoder{
+		Transformer: &decoder{true},
+	}
+}
+
+func (e enc) NewEncoder() *encoding.Encoder {
+	return &encoding.Encoder{
+		Transformer: &encoder{},
+	}
+}
+
+// Encoding is the modified UTF-7 encoding.
+var Encoding encoding.Encoding = enc{}
--- a/vendor/github.com/emersion/go-imap/write.go
+++ b/vendor/github.com/emersion/go-imap/write.go
@@ -0,0 +1,255 @@
+package imap
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"strconv"
+	"time"
+	"unicode"
+)
+
+type flusher interface {
+	Flush() error
+}
+
+type (
+	// A raw string.
+	RawString string
+)
+
+type WriterTo interface {
+	WriteTo(w *Writer) error
+}
+
+func formatNumber(num uint32) string {
+	return strconv.FormatUint(uint64(num), 10)
+}
+
+// Convert a string list to a field list.
+func FormatStringList(list []string) (fields []interface{}) {
+	fields = make([]interface{}, len(list))
+	for i, v := range list {
+		fields[i] = v
+	}
+	return
+}
+
+// Check if a string is 8-bit clean.
+func isAscii(s string) bool {
+	for _, c := range s {
+		if c > unicode.MaxASCII || unicode.IsControl(c) {
+			return false
+		}
+	}
+	return true
+}
+
+// An IMAP writer.
+type Writer struct {
+	io.Writer
+
+	AllowAsyncLiterals bool
+
+	continues <-chan bool
+}
+
+// Helper function to write a string to w.
+func (w *Writer) writeString(s string) error {
+	_, err := io.WriteString(w.Writer, s)
+	return err
+}
+
+func (w *Writer) writeCrlf() error {
+	if err := w.writeString(crlf); err != nil {
+		return err
+	}
+
+	return w.Flush()
+}
+
+func (w *Writer) writeNumber(num uint32) error {
+	return w.writeString(formatNumber(num))
+}
+
+func (w *Writer) writeQuoted(s string) error {
+	return w.writeString(strconv.Quote(s))
+}
+
+func (w *Writer) writeQuotedOrLiteral(s string) error {
+	if !isAscii(s) {
+		// IMAP doesn't allow 8-bit data outside literals
+		return w.writeLiteral(bytes.NewBufferString(s))
+	}
+
+	return w.writeQuoted(s)
+}
+
+func (w *Writer) writeDateTime(t time.Time, layout string) error {
+	if t.IsZero() {
+		return w.writeString(nilAtom)
+	}
+	return w.writeQuoted(t.Format(layout))
+}
+
+func (w *Writer) writeFields(fields []interface{}) error {
+	for i, field := range fields {
+		if i > 0 { // Write separator
+			if err := w.writeString(string(sp)); err != nil {
+				return err
+			}
+		}
+
+		if err := w.writeField(field); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (w *Writer) writeList(fields []interface{}) error {
+	if err := w.writeString(string(listStart)); err != nil {
+		return err
+	}
+
+	if err := w.writeFields(fields); err != nil {
+		return err
+	}
+
+	return w.writeString(string(listEnd))
+}
+
+// LiteralLengthErr is returned when the Len() of the Literal object does not
+// match the actual length of the byte stream.
+type LiteralLengthErr struct {
+	Actual   int
+	Expected int
+}
+
+func (e LiteralLengthErr) Error() string {
+	return fmt.Sprintf("imap: size of Literal is not equal to Len() (%d != %d)", e.Expected, e.Actual)
+}
+
+func (w *Writer) writeLiteral(l Literal) error {
+	if l == nil {
+		return w.writeString(nilAtom)
+	}
+
+	unsyncLiteral := w.AllowAsyncLiterals && l.Len() <= 4096
+
+	header := string(literalStart) + strconv.Itoa(l.Len())
+	if unsyncLiteral {
+		header += string('+')
+	}
+	header += string(literalEnd) + crlf
+	if err := w.writeString(header); err != nil {
+		return err
+	}
+
+	// If a channel is available, wait for a continuation request before sending data
+	if !unsyncLiteral && w.continues != nil {
+		// Make sure to flush the writer, otherwise we may never receive a continuation request
+		if err := w.Flush(); err != nil {
+			return err
+		}
+
+		if !<-w.continues {
+			return fmt.Errorf("imap: cannot send literal: no continuation request received")
+		}
+	}
+
+	// In case of bufio.Buffer, it will be 0 after io.Copy.
+	literalLen := int64(l.Len())
+
+	n, err := io.CopyN(w, l, literalLen)
+	if err != nil {
+		if err == io.EOF && n != literalLen {
+			return LiteralLengthErr{int(n), l.Len()}
+		}
+		return err
+	}
+	extra, _ := io.Copy(ioutil.Discard, l)
+	if extra != 0 {
+		return LiteralLengthErr{int(n + extra), l.Len()}
+	}
+
+	return nil
+}
+
+func (w *Writer) writeField(field interface{}) error {
+	if field == nil {
+		return w.writeString(nilAtom)
+	}
+
+	switch field := field.(type) {
+	case RawString:
+		return w.writeString(string(field))
+	case string:
+		return w.writeQuotedOrLiteral(field)
+	case int:
+		return w.writeNumber(uint32(field))
+	case uint32:
+		return w.writeNumber(field)
+	case Literal:
+		return w.writeLiteral(field)
+	case []interface{}:
+		return w.writeList(field)
+	case envelopeDateTime:
+		return w.writeDateTime(time.Time(field), envelopeDateTimeLayout)
+	case searchDate:
+		return w.writeDateTime(time.Time(field), searchDateLayout)
+	case Date:
+		return w.writeDateTime(time.Time(field), DateLayout)
+	case DateTime:
+		return w.writeDateTime(time.Time(field), DateTimeLayout)
+	case time.Time:
+		return w.writeDateTime(field, DateTimeLayout)
+	case *SeqSet:
+		return w.writeString(field.String())
+	case *BodySectionName:
+		// Can contain spaces - that's why we don't just pass it as a string
+		return w.writeString(string(field.FetchItem()))
+	}
+
+	return fmt.Errorf("imap: cannot format field: %v", field)
+}
+
+func (w *Writer) writeRespCode(code StatusRespCode, args []interface{}) error {
+	if err := w.writeString(string(respCodeStart)); err != nil {
+		return err
+	}
+
+	fields := []interface{}{RawString(code)}
+	fields = append(fields, args...)
+
+	if err := w.writeFields(fields); err != nil {
+		return err
+	}
+
+	return w.writeString(string(respCodeEnd))
+}
+
+func (w *Writer) writeLine(fields ...interface{}) error {
+	if err := w.writeFields(fields); err != nil {
+		return err
+	}
+
+	return w.writeCrlf()
+}
+
+func (w *Writer) Flush() error {
+	if f, ok := w.Writer.(flusher); ok {
+		return f.Flush()
+	}
+	return nil
+}
+
+func NewWriter(w io.Writer) *Writer {
+	return &Writer{Writer: w}
+}
+
+func NewClientWriter(w io.Writer, continues <-chan bool) *Writer {
+	return &Writer{Writer: w, continues: continues}
+}
--- a/vendor/github.com/emersion/go-message/.build.yml
+++ b/vendor/github.com/emersion/go-message/.build.yml
@@ -0,0 +1,17 @@
+image: alpine/edge
+packages:
+  - go
+sources:
+  - https://github.com/emersion/go-message
+artifacts:
+  - coverage.html
+tasks:
+  - build: |
+      cd go-message
+      go build -v ./...
+  - test: |
+      cd go-message
+      go test -coverprofile=coverage.txt -covermode=atomic ./...
+  - coverage: |
+      cd go-message
+      go tool cover -html=coverage.txt -o ~/coverage.html
--- a/vendor/github.com/emersion/go-message/.gitignore
+++ b/vendor/github.com/emersion/go-message/.gitignore
@@ -0,0 +1,24 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof
--- a/vendor/github.com/emersion/go-message/LICENSE
+++ b/vendor/github.com/emersion/go-message/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 emersion
+
+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.
--- a/vendor/github.com/emersion/go-message/README.md
+++ b/vendor/github.com/emersion/go-message/README.md
@@ -0,0 +1,31 @@
+# go-message
+
+[![godocs.io](https://godocs.io/github.com/emersion/go-message?status.svg)](https://godocs.io/github.com/emersion/go-message)
+[![builds.sr.ht status](https://builds.sr.ht/~emersion/go-message/commits.svg)](https://builds.sr.ht/~emersion/go-message/commits?)
+
+A Go library for the Internet Message Format. It implements:
+
+* [RFC 5322]: Internet Message Format
+* [RFC 2045], [RFC 2046] and [RFC 2047]: Multipurpose Internet Mail Extensions
+* [RFC 2183]: Content-Disposition Header Field
+
+## Features
+
+* Streaming API
+* Automatic encoding and charset handling (to decode all charsets, add
+  `import _ "github.com/emersion/go-message/charset"` to your application)
+* A [`mail`](https://godocs.io/github.com/emersion/go-message/mail) subpackage
+  to read and write mail messages
+* DKIM-friendly
+* A [`textproto`](https://godocs.io/github.com/emersion/go-message/textproto)
+  subpackage that just implements the wire format
+
+## License
+
+MIT
+
+[RFC 5322]: https://tools.ietf.org/html/rfc5322
+[RFC 2045]: https://tools.ietf.org/html/rfc2045
+[RFC 2046]: https://tools.ietf.org/html/rfc2046
+[RFC 2047]: https://tools.ietf.org/html/rfc2047
+[RFC 2183]: https://tools.ietf.org/html/rfc2183
--- a/vendor/github.com/emersion/go-message/charset.go
+++ b/vendor/github.com/emersion/go-message/charset.go
@@ -0,0 +1,66 @@
+package message
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"mime"
+	"strings"
+)
+
+type UnknownCharsetError struct {
+	e error
+}
+
+func (u UnknownCharsetError) Unwrap() error { return u.e }
+
+func (u UnknownCharsetError) Error() string {
+	return "unknown charset: " + u.e.Error()
+}
+
+// IsUnknownCharset returns a boolean indicating whether the error is known to
+// report that the charset advertised by the entity is unknown.
+func IsUnknownCharset(err error) bool {
+	return errors.As(err, new(UnknownCharsetError))
+}
+
+// CharsetReader, if non-nil, defines a function to generate charset-conversion
+// readers, converting from the provided charset into UTF-8. Charsets are always
+// lower-case. utf-8 and us-ascii charsets are handled by default. One of the
+// the CharsetReader's result values must be non-nil.
+//
+// Importing github.com/emersion/go-message/charset will set CharsetReader to
+// a function that handles most common charsets. Alternatively, CharsetReader
+// can be set to e.g. golang.org/x/net/html/charset.NewReaderLabel.
+var CharsetReader func(charset string, input io.Reader) (io.Reader, error)
+
+// charsetReader calls CharsetReader if non-nil.
+func charsetReader(charset string, input io.Reader) (io.Reader, error) {
+	charset = strings.ToLower(charset)
+	if charset == "utf-8" || charset == "us-ascii" {
+		return input, nil
+	}
+	if CharsetReader != nil {
+		r, err := CharsetReader(charset, input)
+		if err != nil {
+			return r, UnknownCharsetError{err}
+		}
+		return r, nil
+	}
+	return input, UnknownCharsetError{fmt.Errorf("message: unhandled charset %q", charset)}
+}
+
+// decodeHeader decodes an internationalized header field. If it fails, it
+// returns the input string and the error.
+func decodeHeader(s string) (string, error) {
+	wordDecoder := mime.WordDecoder{CharsetReader: charsetReader}
+	dec, err := wordDecoder.DecodeHeader(s)
+	if err != nil {
+		return s, err
+	}
+	return dec, nil
+}
+
+func encodeHeader(s string) string {
+	return mime.QEncoding.Encode("utf-8", s)
+}
--- a/vendor/github.com/emersion/go-message/encoding.go
+++ b/vendor/github.com/emersion/go-message/encoding.go
@@ -0,0 +1,88 @@
+package message
+
+import (
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"io"
+	"mime/quotedprintable"
+	"strings"
+
+	"github.com/emersion/go-textwrapper"
+)
+
+type UnknownEncodingError struct {
+	e error
+}
+
+func (u UnknownEncodingError) Unwrap() error { return u.e }
+
+func (u UnknownEncodingError) Error() string {
+	return "encoding error: " + u.e.Error()
+}
+
+// IsUnknownEncoding returns a boolean indicating whether the error is known to
+// report that the encoding advertised by the entity is unknown.
+func IsUnknownEncoding(err error) bool {
+	return errors.As(err, new(UnknownEncodingError))
+}
+
+func encodingReader(enc string, r io.Reader) (io.Reader, error) {
+	var dec io.Reader
+	switch strings.ToLower(enc) {
+	case "quoted-printable":
+		dec = quotedprintable.NewReader(r)
+	case "base64":
+		wrapped := &whitespaceReplacingReader{wrapped: r}
+		dec = base64.NewDecoder(base64.StdEncoding, wrapped)
+	case "7bit", "8bit", "binary", "":
+		dec = r
+	default:
+		return nil, fmt.Errorf("unhandled encoding %q", enc)
+	}
+	return dec, nil
+}
+
+type nopCloser struct {
+	io.Writer
+}
+
+func (nopCloser) Close() error {
+	return nil
+}
+
+func encodingWriter(enc string, w io.Writer) (io.WriteCloser, error) {
+	var wc io.WriteCloser
+	switch strings.ToLower(enc) {
+	case "quoted-printable":
+		wc = quotedprintable.NewWriter(w)
+	case "base64":
+		wc = base64.NewEncoder(base64.StdEncoding, textwrapper.NewRFC822(w))
+	case "7bit", "8bit":
+		wc = nopCloser{textwrapper.New(w, "\r\n", 1000)}
+	case "binary", "":
+		wc = nopCloser{w}
+	default:
+		return nil, fmt.Errorf("unhandled encoding %q", enc)
+	}
+	return wc, nil
+}
+
+// whitespaceReplacingReader replaces space and tab characters with a LF so
+// base64 bodies with a continuation indent can be decoded by the base64 decoder
+// even though it is against the spec.
+type whitespaceReplacingReader struct {
+	wrapped io.Reader
+}
+
+func (r *whitespaceReplacingReader) Read(p []byte) (int, error) {
+	n, err := r.wrapped.Read(p)
+
+	for i := 0; i < n; i++ {
+		if p[i] == ' ' || p[i] == '\t' {
+			p[i] = '\n'
+		}
+	}
+
+	return n, err
+}
--- a/vendor/github.com/emersion/go-message/entity.go
+++ b/vendor/github.com/emersion/go-message/entity.go
@@ -0,0 +1,260 @@
+package message
+
+import (
+	"bufio"
+	"errors"
+	"io"
+	"math"
+	"strings"
+
+	"github.com/emersion/go-message/textproto"
+)
+
+// An Entity is either a whole message or a one of the parts in the body of a
+// multipart entity.
+type Entity struct {
+	Header Header    // The entity's header.
+	Body   io.Reader // The decoded entity's body.
+
+	mediaType   string
+	mediaParams map[string]string
+}
+
+// New makes a new message with the provided header and body. The entity's
+// transfer encoding and charset are automatically decoded to UTF-8.
+//
+// If the message uses an unknown transfer encoding or charset, New returns an
+// error that verifies IsUnknownCharset, but also returns an Entity that can
+// be read.
+func New(header Header, body io.Reader) (*Entity, error) {
+	var err error
+
+	mediaType, mediaParams, _ := header.ContentType()
+
+	// QUIRK: RFC 2045 section 6.4 specifies that multipart messages can't have
+	// a Content-Transfer-Encoding other than "7bit", "8bit" or "binary".
+	// However some messages in the wild are non-conformant and have it set to
+	// e.g. "quoted-printable". So we just ignore it for multipart.
+	// See https://github.com/emersion/go-message/issues/48
+	if !strings.HasPrefix(mediaType, "multipart/") {
+		enc := header.Get("Content-Transfer-Encoding")
+		if decoded, encErr := encodingReader(enc, body); encErr != nil {
+			err = UnknownEncodingError{encErr}
+		} else {
+			body = decoded
+		}
+	}
+
+	// RFC 2046 section 4.1.2: charset only applies to text/*
+	if strings.HasPrefix(mediaType, "text/") {
+		if ch, ok := mediaParams["charset"]; ok {
+			if converted, charsetErr := charsetReader(ch, body); charsetErr != nil {
+				err = UnknownCharsetError{charsetErr}
+			} else {
+				body = converted
+			}
+		}
+	}
+
+	return &Entity{
+		Header:      header,
+		Body:        body,
+		mediaType:   mediaType,
+		mediaParams: mediaParams,
+	}, err
+}
+
+// NewMultipart makes a new multipart message with the provided header and
+// parts. The Content-Type header must begin with "multipart/".
+//
+// If the message uses an unknown transfer encoding, NewMultipart returns an
+// error that verifies IsUnknownCharset, but also returns an Entity that can
+// be read.
+func NewMultipart(header Header, parts []*Entity) (*Entity, error) {
+	r := &multipartBody{
+		header: header,
+		parts:  parts,
+	}
+
+	return New(header, r)
+}
+
+const defaultMaxHeaderBytes = 1 << 20 // 1 MB
+
+var errHeaderTooBig = errors.New("message: header exceeds maximum size")
+
+// limitedReader is the same as io.LimitedReader, but returns a custom error.
+type limitedReader struct {
+	R io.Reader
+	N int64
+}
+
+func (lr *limitedReader) Read(p []byte) (int, error) {
+	if lr.N <= 0 {
+		return 0, errHeaderTooBig
+	}
+	if int64(len(p)) > lr.N {
+		p = p[0:lr.N]
+	}
+	n, err := lr.R.Read(p)
+	lr.N -= int64(n)
+	return n, err
+}
+
+// ReadOptions are options for ReadWithOptions.
+type ReadOptions struct {
+	// MaxHeaderBytes limits the maximum permissible size of a message header
+	// block. If exceeded, an error will be returned.
+	//
+	// Set to -1 for no limit, set to 0 for the default value (1MB).
+	MaxHeaderBytes int64
+}
+
+// withDefaults returns a sanitised version of the options with defaults/special
+// values accounted for.
+func (o *ReadOptions) withDefaults() *ReadOptions {
+	var out ReadOptions
+	if o != nil {
+		out = *o
+	}
+	if out.MaxHeaderBytes == 0 {
+		out.MaxHeaderBytes = defaultMaxHeaderBytes
+	} else if out.MaxHeaderBytes < 0 {
+		out.MaxHeaderBytes = math.MaxInt64
+	}
+	return &out
+}
+
+// ReadWithOptions see Read, but allows overriding some parameters with
+// ReadOptions.
+//
+// If the message uses an unknown transfer encoding or charset, ReadWithOptions
+// returns an error that verifies IsUnknownCharset or IsUnknownEncoding, but
+// also returns an Entity that can be read.
+func ReadWithOptions(r io.Reader, opts *ReadOptions) (*Entity, error) {
+	opts = opts.withDefaults()
+
+	lr := &limitedReader{R: r, N: opts.MaxHeaderBytes}
+	br := bufio.NewReader(lr)
+
+	h, err := textproto.ReadHeader(br)
+	if err != nil {
+		return nil, err
+	}
+
+	lr.N = math.MaxInt64
+
+	return New(Header{h}, br)
+}
+
+// Read reads a message from r. The message's encoding and charset are
+// automatically decoded to raw UTF-8. Note that this function only reads the
+// message header.
+//
+// If the message uses an unknown transfer encoding or charset, Read returns an
+// error that verifies IsUnknownCharset or IsUnknownEncoding, but also returns
+// an Entity that can be read.
+func Read(r io.Reader) (*Entity, error) {
+	return ReadWithOptions(r, nil)
+}
+
+// MultipartReader returns a MultipartReader that reads parts from this entity's
+// body. If this entity is not multipart, it returns nil.
+func (e *Entity) MultipartReader() MultipartReader {
+	if !strings.HasPrefix(e.mediaType, "multipart/") {
+		return nil
+	}
+	if mb, ok := e.Body.(*multipartBody); ok {
+		return mb
+	}
+	return &multipartReader{textproto.NewMultipartReader(e.Body, e.mediaParams["boundary"])}
+}
+
+// writeBodyTo writes this entity's body to w (without the header).
+func (e *Entity) writeBodyTo(w *Writer) error {
+	var err error
+	if mb, ok := e.Body.(*multipartBody); ok {
+		err = mb.writeBodyTo(w)
+	} else {
+		_, err = io.Copy(w, e.Body)
+	}
+	return err
+}
+
+// WriteTo writes this entity's header and body to w.
+func (e *Entity) WriteTo(w io.Writer) error {
+	ew, err := CreateWriter(w, e.Header)
+	if err != nil {
+		return err
+	}
+	defer ew.Close()
+
+	return e.writeBodyTo(ew)
+}
+
+// WalkFunc is the type of the function called for each part visited by Walk.
+//
+// The path argument is a list of multipart indices leading to the part. The
+// root part has a nil path.
+//
+// If there was an encoding error walking to a part, the incoming error will
+// describe the problem and the function can decide how to handle that error.
+//
+// Unlike IMAP part paths, indices start from 0 (instead of 1) and a
+// non-multipart message has a nil path (instead of {1}).
+//
+// If an error is returned, processing stops.
+type WalkFunc func(path []int, entity *Entity, err error) error
+
+// Walk walks the entity's multipart tree, calling walkFunc for each part in
+// the tree, including the root entity.
+//
+// Walk consumes the entity.
+func (e *Entity) Walk(walkFunc WalkFunc) error {
+	var multipartReaders []MultipartReader
+	var path []int
+	part := e
+	for {
+		var err error
+		if part == nil {
+			if len(multipartReaders) == 0 {
+				break
+			}
+
+			// Get the next part from the last multipart reader
+			mr := multipartReaders[len(multipartReaders)-1]
+			part, err = mr.NextPart()
+			if err == io.EOF {
+				multipartReaders = multipartReaders[:len(multipartReaders)-1]
+				path = path[:len(path)-1]
+				continue
+			} else if IsUnknownEncoding(err) || IsUnknownCharset(err) {
+				// Forward the error to walkFunc
+			} else if err != nil {
+				return err
+			}
+
+			path[len(path)-1]++
+		}
+
+		// Copy the path since we'll mutate it on the next iteration
+		var pathCopy []int
+		if len(path) > 0 {
+			pathCopy = make([]int, len(path))
+			copy(pathCopy, path)
+		}
+
+		if err := walkFunc(pathCopy, part, err); err != nil {
+			return err
+		}
+
+		if mr := part.MultipartReader(); mr != nil {
+			multipartReaders = append(multipartReaders, mr)
+			path = append(path, -1)
+		}
+
+		part = nil
+	}
+
+	return nil
+}
--- a/vendor/github.com/emersion/go-message/header.go
+++ b/vendor/github.com/emersion/go-message/header.go
@@ -0,0 +1,118 @@
+package message
+
+import (
+	"mime"
+
+	"github.com/emersion/go-message/textproto"
+)
+
+func parseHeaderWithParams(s string) (f string, params map[string]string, err error) {
+	f, params, err = mime.ParseMediaType(s)
+	if err != nil {
+		return s, nil, err
+	}
+	for k, v := range params {
+		params[k], _ = decodeHeader(v)
+	}
+	return
+}
+
+func formatHeaderWithParams(f string, params map[string]string) string {
+	encParams := make(map[string]string)
+	for k, v := range params {
+		encParams[k] = encodeHeader(v)
+	}
+	return mime.FormatMediaType(f, encParams)
+}
+
+// HeaderFields iterates over header fields.
+type HeaderFields interface {
+	textproto.HeaderFields
+
+	// Text parses the value of the current field as plaintext. The field
+	// charset is decoded to UTF-8. If the header field's charset is unknown,
+	// the raw field value is returned and the error verifies IsUnknownCharset.
+	Text() (string, error)
+}
+
+type headerFields struct {
+	textproto.HeaderFields
+}
+
+func (hf *headerFields) Text() (string, error) {
+	return decodeHeader(hf.Value())
+}
+
+// A Header represents the key-value pairs in a message header.
+type Header struct {
+	textproto.Header
+}
+
+// HeaderFromMap creates a header from a map of header fields.
+//
+// This function is provided for interoperability with the standard library.
+// If possible, ReadHeader should be used instead to avoid loosing information.
+// The map representation looses the ordering of the fields, the capitalization
+// of the header keys, and the whitespace of the original header.
+func HeaderFromMap(m map[string][]string) Header {
+	return Header{textproto.HeaderFromMap(m)}
+}
+
+// ContentType parses the Content-Type header field.
+//
+// If no Content-Type is specified, it returns "text/plain".
+func (h *Header) ContentType() (t string, params map[string]string, err error) {
+	v := h.Get("Content-Type")
+	if v == "" {
+		return "text/plain", nil, nil
+	}
+	return parseHeaderWithParams(v)
+}
+
+// SetContentType formats the Content-Type header field.
+func (h *Header) SetContentType(t string, params map[string]string) {
+	h.Set("Content-Type", formatHeaderWithParams(t, params))
+}
+
+// ContentDisposition parses the Content-Disposition header field, as defined in
+// RFC 2183.
+func (h *Header) ContentDisposition() (disp string, params map[string]string, err error) {
+	return parseHeaderWithParams(h.Get("Content-Disposition"))
+}
+
+// SetContentDisposition formats the Content-Disposition header field, as
+// defined in RFC 2183.
+func (h *Header) SetContentDisposition(disp string, params map[string]string) {
+	h.Set("Content-Disposition", formatHeaderWithParams(disp, params))
+}
+
+// Text parses a plaintext header field. The field charset is automatically
+// decoded to UTF-8. If the header field's charset is unknown, the raw field
+// value is returned and the error verifies IsUnknownCharset.
+func (h *Header) Text(k string) (string, error) {
+	return decodeHeader(h.Get(k))
+}
+
+// SetText sets a plaintext header field.
+func (h *Header) SetText(k, v string) {
+	h.Set(k, encodeHeader(v))
+}
+
+// Copy creates a stand-alone copy of the header.
+func (h *Header) Copy() Header {
+	return Header{h.Header.Copy()}
+}
+
+// Fields iterates over all the header fields.
+//
+// The header may not be mutated while iterating, except using HeaderFields.Del.
+func (h *Header) Fields() HeaderFields {
+	return &headerFields{h.Header.Fields()}
+}
+
+// FieldsByKey iterates over all fields having the specified key.
+//
+// The header may not be mutated while iterating, except using HeaderFields.Del.
+func (h *Header) FieldsByKey(k string) HeaderFields {
+	return &headerFields{h.Header.FieldsByKey(k)}
+}
--- a/vendor/github.com/emersion/go-message/mail/address.go
+++ b/vendor/github.com/emersion/go-message/mail/address.go
@@ -0,0 +1,42 @@
+package mail
+
+import (
+	"mime"
+	"net/mail"
+	"strings"
+
+	"github.com/emersion/go-message"
+)
+
+// Address represents a single mail address.
+// The type alias ensures that a net/mail.Address can be used wherever an
+// Address is expected
+type Address = mail.Address
+
+func formatAddressList(l []*Address) string {
+	formatted := make([]string, len(l))
+	for i, a := range l {
+		formatted[i] = a.String()
+	}
+	return strings.Join(formatted, ", ")
+}
+
+// ParseAddress parses a single RFC 5322 address, e.g. "Barry Gibbs <bg@example.com>"
+// Use this function only if you parse from a string, if you have a Header use
+// Header.AddressList instead
+func ParseAddress(address string) (*Address, error) {
+	parser := mail.AddressParser{
+		&mime.WordDecoder{message.CharsetReader},
+	}
+	return parser.Parse(address)
+}
+
+// ParseAddressList parses the given string as a list of addresses.
+// Use this function only if you parse from a string, if you have a Header use
+// Header.AddressList instead
+func ParseAddressList(list string) ([]*Address, error) {
+	parser := mail.AddressParser{
+		&mime.WordDecoder{message.CharsetReader},
+	}
+	return parser.ParseList(list)
+}
--- a/vendor/github.com/emersion/go-message/mail/attachment.go
+++ b/vendor/github.com/emersion/go-message/mail/attachment.go
@@ -0,0 +1,30 @@
+package mail
+
+import (
+	"github.com/emersion/go-message"
+)
+
+// An AttachmentHeader represents an attachment's header.
+type AttachmentHeader struct {
+	message.Header
+}
+
+// Filename parses the attachment's filename.
+func (h *AttachmentHeader) Filename() (string, error) {
+	_, params, err := h.ContentDisposition()
+
+	filename, ok := params["filename"]
+	if !ok {
+		// Using "name" in Content-Type is discouraged
+		_, params, err = h.ContentType()
+		filename = params["name"]
+	}
+
+	return filename, err
+}
+
+// SetFilename formats the attachment's filename.
+func (h *AttachmentHeader) SetFilename(filename string) {
+	dispParams := map[string]string{"filename": filename}
+	h.SetContentDisposition("attachment", dispParams)
+}
--- a/vendor/github.com/emersion/go-message/mail/header.go
+++ b/vendor/github.com/emersion/go-message/mail/header.go
@@ -0,0 +1,358 @@
+package mail
+
+import (
+	"crypto/rand"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"net/mail"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	"github.com/emersion/go-message"
+)
+
+const dateLayout = "Mon, 02 Jan 2006 15:04:05 -0700"
+
+type headerParser struct {
+	s string
+}
+
+func (p *headerParser) len() int {
+	return len(p.s)
+}
+
+func (p *headerParser) empty() bool {
+	return p.len() == 0
+}
+
+func (p *headerParser) peek() byte {
+	return p.s[0]
+}
+
+func (p *headerParser) consume(c byte) bool {
+	if p.empty() || p.peek() != c {
+		return false
+	}
+	p.s = p.s[1:]
+	return true
+}
+
+// skipSpace skips the leading space and tab characters.
+func (p *headerParser) skipSpace() {
+	p.s = strings.TrimLeft(p.s, " \t")
+}
+
+// skipCFWS skips CFWS as defined in RFC5322. It returns false if the CFWS is
+// malformed.
+func (p *headerParser) skipCFWS() bool {
+	p.skipSpace()
+
+	for {
+		if !p.consume('(') {
+			break
+		}
+
+		if _, ok := p.consumeComment(); !ok {
+			return false
+		}
+
+		p.skipSpace()
+	}
+
+	return true
+}
+
+func (p *headerParser) consumeComment() (string, bool) {
+	// '(' already consumed.
+	depth := 1
+
+	var comment string
+	for {
+		if p.empty() || depth == 0 {
+			break
+		}
+
+		if p.peek() == '\\' && p.len() > 1 {
+			p.s = p.s[1:]
+		} else if p.peek() == '(' {
+			depth++
+		} else if p.peek() == ')' {
+			depth--
+		}
+
+		if depth > 0 {
+			comment += p.s[:1]
+		}
+
+		p.s = p.s[1:]
+	}
+
+	return comment, depth == 0
+}
+
+func (p *headerParser) parseAtomText(dot bool) (string, error) {
+	i := 0
+	for {
+		r, size := utf8.DecodeRuneInString(p.s[i:])
+		if size == 1 && r == utf8.RuneError {
+			return "", fmt.Errorf("mail: invalid UTF-8 in atom-text: %q", p.s)
+		} else if size == 0 || !isAtext(r, dot) {
+			break
+		}
+		i += size
+	}
+	if i == 0 {
+		return "", errors.New("mail: invalid string")
+	}
+
+	var atom string
+	atom, p.s = p.s[:i], p.s[i:]
+	return atom, nil
+}
+
+func isAtext(r rune, dot bool) bool {
+	switch r {
+	case '.':
+		return dot
+	// RFC 5322 3.2.3 specials
+	case '(', ')', '[', ']', ';', '@', '\\', ',':
+		return false
+	case '<', '>', '"', ':':
+		return false
+	}
+	return isVchar(r)
+}
+
+// isVchar reports whether r is an RFC 5322 VCHAR character.
+func isVchar(r rune) bool {
+	// Visible (printing) characters
+	return '!' <= r && r <= '~' || isMultibyte(r)
+}
+
+// isMultibyte reports whether r is a multi-byte UTF-8 character
+// as supported by RFC 6532
+func isMultibyte(r rune) bool {
+	return r >= utf8.RuneSelf
+}
+
+func (p *headerParser) parseNoFoldLiteral() (string, error) {
+	if !p.consume('[') {
+		return "", errors.New("mail: missing '[' in no-fold-literal")
+	}
+
+	i := 0
+	for {
+		r, size := utf8.DecodeRuneInString(p.s[i:])
+		if size == 1 && r == utf8.RuneError {
+			return "", fmt.Errorf("mail: invalid UTF-8 in no-fold-literal: %q", p.s)
+		} else if size == 0 || !isDtext(r) {
+			break
+		}
+		i += size
+	}
+	var lit string
+	lit, p.s = p.s[:i], p.s[i:]
+
+	if !p.consume(']') {
+		return "", errors.New("mail: missing ']' in no-fold-literal")
+	}
+	return "[" + lit + "]", nil
+}
+
+func isDtext(r rune) bool {
+	switch r {
+	case '[', ']', '\\':
+		return false
+	}
+	return isVchar(r)
+}
+
+func (p *headerParser) parseMsgID() (string, error) {
+	if !p.skipCFWS() {
+		return "", errors.New("mail: malformed parenthetical comment")
+	}
+
+	if !p.consume('<') {
+		return "", errors.New("mail: missing '<' in msg-id")
+	}
+
+	left, err := p.parseAtomText(true)
+	if err != nil {
+		return "", err
+	}
+
+	if !p.consume('@') {
+		return "", errors.New("mail: missing '@' in msg-id")
+	}
+
+	var right string
+	if !p.empty() && p.peek() == '[' {
+		// no-fold-literal
+		right, err = p.parseNoFoldLiteral()
+	} else {
+		right, err = p.parseAtomText(true)
+		if err != nil {
+			return "", err
+		}
+	}
+
+	if !p.consume('>') {
+		return "", errors.New("mail: missing '>' in msg-id")
+	}
+
+	if !p.skipCFWS() {
+		return "", errors.New("mail: malformed parenthetical comment")
+	}
+
+	return left + "@" + right, nil
+}
+
+// A Header is a mail header.
+type Header struct {
+	message.Header
+}
+
+// HeaderFromMap creates a header from a map of header fields.
+//
+// This function is provided for interoperability with the standard library.
+// If possible, ReadHeader should be used instead to avoid loosing information.
+// The map representation looses the ordering of the fields, the capitalization
+// of the header keys, and the whitespace of the original header.
+func HeaderFromMap(m map[string][]string) Header {
+	return Header{message.HeaderFromMap(m)}
+}
+
+// AddressList parses the named header field as a list of addresses. If the
+// header field is missing, it returns nil.
+//
+// This can be used on From, Sender, Reply-To, To, Cc and Bcc header fields.
+func (h *Header) AddressList(key string) ([]*Address, error) {
+	v := h.Get(key)
+	if v == "" {
+		return nil, nil
+	}
+	return ParseAddressList(v)
+}
+
+// SetAddressList formats the named header field to the provided list of
+// addresses.
+//
+// This can be used on From, Sender, Reply-To, To, Cc and Bcc header fields.
+func (h *Header) SetAddressList(key string, addrs []*Address) {
+	if len(addrs) > 0 {
+		h.Set(key, formatAddressList(addrs))
+	} else {
+		h.Del(key)
+	}
+}
+
+// Date parses the Date header field.
+func (h *Header) Date() (time.Time, error) {
+	return mail.ParseDate(h.Get("Date"))
+}
+
+// SetDate formats the Date header field.
+func (h *Header) SetDate(t time.Time) {
+	h.Set("Date", t.Format(dateLayout))
+}
+
+// Subject parses the Subject header field. If there is an error, the raw field
+// value is returned alongside the error.
+func (h *Header) Subject() (string, error) {
+	return h.Text("Subject")
+}
+
+// SetSubject formats the Subject header field.
+func (h *Header) SetSubject(s string) {
+	h.SetText("Subject", s)
+}
+
+// MessageID parses the Message-ID field. It returns the message identifier,
+// without the angle brackets. If the message doesn't have a Message-ID header
+// field, it returns an empty string.
+func (h *Header) MessageID() (string, error) {
+	v := h.Get("Message-Id")
+	if v == "" {
+		return "", nil
+	}
+
+	p := headerParser{v}
+	return p.parseMsgID()
+}
+
+// MsgIDList parses a list of message identifiers. It returns message
+// identifiers without angle brackets. If the header field is missing, it
+// returns nil.
+//
+// This can be used on In-Reply-To and References header fields.
+func (h *Header) MsgIDList(key string) ([]string, error) {
+	v := h.Get(key)
+	if v == "" {
+		return nil, nil
+	}
+
+	p := headerParser{v}
+	var l []string
+	for !p.empty() {
+		msgID, err := p.parseMsgID()
+		if err != nil {
+			return l, err
+		}
+		l = append(l, msgID)
+	}
+
+	return l, nil
+}
+
+// GenerateMessageID generates an RFC 2822-compliant Message-Id based on the
+// informational draft "Recommendations for generating Message IDs", for lack
+// of a better authoritative source.
+func (h *Header) GenerateMessageID() error {
+	now := uint64(time.Now().UnixNano())
+
+	nonceByte := make([]byte, 8)
+	if _, err := rand.Read(nonceByte); err != nil {
+		return err
+	}
+	nonce := binary.BigEndian.Uint64(nonceByte)
+
+	hostname, err := os.Hostname()
+	if err != nil {
+		return err
+	}
+
+	msgID := fmt.Sprintf("%s.%s@%s", base36(now), base36(nonce), hostname)
+	h.SetMessageID(msgID)
+	return nil
+}
+
+func base36(input uint64) string {
+	return strings.ToUpper(strconv.FormatUint(input, 36))
+}
+
+// SetMessageID sets the Message-ID field. id is the message identifier,
+// without the angle brackets.
+func (h *Header) SetMessageID(id string) {
+	h.Set("Message-Id", "<"+id+">")
+}
+
+// SetMsgIDList formats a list of message identifiers. Message identifiers
+// don't include angle brackets.
+//
+// This can be used on In-Reply-To and References header fields.
+func (h *Header) SetMsgIDList(key string, l []string) {
+	if len(l) > 0 {
+		h.Set(key, "<"+strings.Join(l, "> <")+">")
+	} else {
+		h.Del(key)
+	}
+}
+
+// Copy creates a stand-alone copy of the header.
+func (h *Header) Copy() Header {
+	return Header{h.Header.Copy()}
+}
--- a/vendor/github.com/emersion/go-message/mail/inline.go
+++ b/vendor/github.com/emersion/go-message/mail/inline.go
@@ -0,0 +1,10 @@
+package mail
+
+import (
+	"github.com/emersion/go-message"
+)
+
+// A InlineHeader represents a message text header.
+type InlineHeader struct {
+	message.Header
+}
--- a/vendor/github.com/emersion/go-message/mail/mail.go
+++ b/vendor/github.com/emersion/go-message/mail/mail.go
@@ -0,0 +1,9 @@
+// Package mail implements reading and writing mail messages.
+//
+// This package assumes that a mail message contains one or more text parts and
+// zero or more attachment parts. Each text part represents a different version
+// of the message content (e.g. a different type, a different language and so
+// on).
+//
+// RFC 5322 defines the Internet Message Format.
+package mail
--- a/vendor/github.com/emersion/go-message/mail/reader.go
+++ b/vendor/github.com/emersion/go-message/mail/reader.go
@@ -0,0 +1,130 @@
+package mail
+
+import (
+	"container/list"
+	"io"
+	"strings"
+
+	"github.com/emersion/go-message"
+)
+
+// A PartHeader is a mail part header. It contains convenience functions to get
+// and set header fields.
+type PartHeader interface {
+	// Add adds the key, value pair to the header.
+	Add(key, value string)
+	// Del deletes the values associated with key.
+	Del(key string)
+	// Get gets the first value associated with the given key. If there are no
+	// values associated with the key, Get returns "".
+	Get(key string) string
+	// Set sets the header entries associated with key to the single element
+	// value. It replaces any existing values associated with key.
+	Set(key, value string)
+}
+
+// A Part is either a mail text or an attachment. Header is either a InlineHeader
+// or an AttachmentHeader.
+type Part struct {
+	Header PartHeader
+	Body   io.Reader
+}
+
+// A Reader reads a mail message.
+type Reader struct {
+	Header Header
+
+	e       *message.Entity
+	readers *list.List
+}
+
+// NewReader creates a new mail reader.
+func NewReader(e *message.Entity) *Reader {
+	mr := e.MultipartReader()
+	if mr == nil {
+		// Artificially create a multipart entity
+		// With this header, no error will be returned by message.NewMultipart
+		var h message.Header
+		h.Set("Content-Type", "multipart/mixed")
+		me, _ := message.NewMultipart(h, []*message.Entity{e})
+		mr = me.MultipartReader()
+	}
+
+	l := list.New()
+	l.PushBack(mr)
+
+	return &Reader{Header{e.Header}, e, l}
+}
+
+// CreateReader reads a mail header from r and returns a new mail reader.
+//
+// If the message uses an unknown transfer encoding or charset, CreateReader
+// returns an error that verifies message.IsUnknownCharset, but also returns a
+// Reader that can be used.
+func CreateReader(r io.Reader) (*Reader, error) {
+	e, err := message.Read(r)
+	if err != nil && !message.IsUnknownCharset(err) {
+		return nil, err
+	}
+
+	return NewReader(e), err
+}
+
+// NextPart returns the next mail part. If there is no more part, io.EOF is
+// returned as error.
+//
+// The returned Part.Body must be read completely before the next call to
+// NextPart, otherwise it will be discarded.
+//
+// If the part uses an unknown transfer encoding or charset, NextPart returns an
+// error that verifies message.IsUnknownCharset, but also returns a Part that
+// can be used.
+func (r *Reader) NextPart() (*Part, error) {
+	for r.readers.Len() > 0 {
+		e := r.readers.Back()
+		mr := e.Value.(message.MultipartReader)
+
+		p, err := mr.NextPart()
+		if err == io.EOF {
+			// This whole multipart entity has been read, continue with the next one
+			r.readers.Remove(e)
+			continue
+		} else if err != nil && !message.IsUnknownCharset(err) {
+			return nil, err
+		}
+
+		if pmr := p.MultipartReader(); pmr != nil {
+			// This is a multipart part, read it
+			r.readers.PushBack(pmr)
+		} else {
+			// This is a non-multipart part, return a mail part
+			mp := &Part{Body: p.Body}
+			t, _, _ := p.Header.ContentType()
+			disp, _, _ := p.Header.ContentDisposition()
+			if disp == "inline" || (disp != "attachment" && strings.HasPrefix(t, "text/")) {
+				mp.Header = &InlineHeader{p.Header}
+			} else {
+				mp.Header = &AttachmentHeader{p.Header}
+			}
+			return mp, err
+		}
+	}
+
+	return nil, io.EOF
+}
+
+// Close finishes the reader.
+func (r *Reader) Close() error {
+	for r.readers.Len() > 0 {
+		e := r.readers.Back()
+		mr := e.Value.(message.MultipartReader)
+
+		if err := mr.Close(); err != nil {
+			return err
+		}
+
+		r.readers.Remove(e)
+	}
+
+	return nil
+}
--- a/vendor/github.com/emersion/go-message/mail/writer.go
+++ b/vendor/github.com/emersion/go-message/mail/writer.go
@@ -0,0 +1,132 @@
+package mail
+
+import (
+	"io"
+	"strings"
+
+	"github.com/emersion/go-message"
+)
+
+func initInlineContentTransferEncoding(h *message.Header) {
+	if !h.Has("Content-Transfer-Encoding") {
+		t, _, _ := h.ContentType()
+		if strings.HasPrefix(t, "text/") {
+			h.Set("Content-Transfer-Encoding", "quoted-printable")
+		} else {
+			h.Set("Content-Transfer-Encoding", "base64")
+		}
+	}
+}
+
+func initInlineHeader(h *InlineHeader) {
+	h.Set("Content-Disposition", "inline")
+	initInlineContentTransferEncoding(&h.Header)
+}
+
+func initAttachmentHeader(h *AttachmentHeader) {
+	disp, _, _ := h.ContentDisposition()
+	if disp != "attachment" {
+		h.Set("Content-Disposition", "attachment")
+	}
+	if !h.Has("Content-Transfer-Encoding") {
+		h.Set("Content-Transfer-Encoding", "base64")
+	}
+}
+
+// A Writer writes a mail message. A mail message contains one or more text
+// parts and zero or more attachments.
+type Writer struct {
+	mw *message.Writer
+}
+
+// CreateWriter writes a mail header to w and creates a new Writer.
+func CreateWriter(w io.Writer, header Header) (*Writer, error) {
+	header = header.Copy() // don't modify the caller's view
+	header.Set("Content-Type", "multipart/mixed")
+
+	mw, err := message.CreateWriter(w, header.Header)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Writer{mw}, nil
+}
+
+// CreateInlineWriter writes a mail header to w. The mail will contain an
+// inline part, allowing to represent the same text in different formats.
+// Attachments cannot be included.
+func CreateInlineWriter(w io.Writer, header Header) (*InlineWriter, error) {
+	header = header.Copy() // don't modify the caller's view
+	header.Set("Content-Type", "multipart/alternative")
+
+	mw, err := message.CreateWriter(w, header.Header)
+	if err != nil {
+		return nil, err
+	}
+
+	return &InlineWriter{mw}, nil
+}
+
+// CreateSingleInlineWriter writes a mail header to w. The mail will contain a
+// single inline part. The body of the part should be written to the returned
+// io.WriteCloser. Only one single inline part should be written, use
+// CreateWriter if you want multiple parts.
+func CreateSingleInlineWriter(w io.Writer, header Header) (io.WriteCloser, error) {
+	header = header.Copy() // don't modify the caller's view
+	initInlineContentTransferEncoding(&header.Header)
+	return message.CreateWriter(w, header.Header)
+}
+
+// CreateInline creates a InlineWriter. One or more parts representing the same
+// text in different formats can be written to a InlineWriter.
+func (w *Writer) CreateInline() (*InlineWriter, error) {
+	var h message.Header
+	h.Set("Content-Type", "multipart/alternative")
+
+	mw, err := w.mw.CreatePart(h)
+	if err != nil {
+		return nil, err
+	}
+	return &InlineWriter{mw}, nil
+}
+
+// CreateSingleInline creates a new single text part with the provided header.
+// The body of the part should be written to the returned io.WriteCloser. Only
+// one single text part should be written, use CreateInline if you want multiple
+// text parts.
+func (w *Writer) CreateSingleInline(h InlineHeader) (io.WriteCloser, error) {
+	h = InlineHeader{h.Header.Copy()} // don't modify the caller's view
+	initInlineHeader(&h)
+	return w.mw.CreatePart(h.Header)
+}
+
+// CreateAttachment creates a new attachment with the provided header. The body
+// of the part should be written to the returned io.WriteCloser.
+func (w *Writer) CreateAttachment(h AttachmentHeader) (io.WriteCloser, error) {
+	h = AttachmentHeader{h.Header.Copy()} // don't modify the caller's view
+	initAttachmentHeader(&h)
+	return w.mw.CreatePart(h.Header)
+}
+
+// Close finishes the Writer.
+func (w *Writer) Close() error {
+	return w.mw.Close()
+}
+
+// InlineWriter writes a mail message's text.
+type InlineWriter struct {
+	mw *message.Writer
+}
+
+// CreatePart creates a new text part with the provided header. The body of the
+// part should be written to the returned io.WriteCloser.
+func (w *InlineWriter) CreatePart(h InlineHeader) (io.WriteCloser, error) {
+	h = InlineHeader{h.Header.Copy()} // don't modify the caller's view
+	initInlineHeader(&h)
+	return w.mw.CreatePart(h.Header)
+}
+
+// Close finishes the InlineWriter.
+func (w *InlineWriter) Close() error {
+	return w.mw.Close()
+}
--- a/vendor/github.com/emersion/go-message/message.go
+++ b/vendor/github.com/emersion/go-message/message.go
@@ -0,0 +1,12 @@
+// Package message implements reading and writing multipurpose messages.
+//
+// RFC 2045, RFC 2046 and RFC 2047 defines MIME, and RFC 2183 defines the
+// Content-Disposition header field.
+//
+// Add this import to your package if you want to handle most common charsets
+// by default:
+//
+//   import (
+//   	_ "github.com/emersion/go-message/charset"
+//   )
+package message
--- a/vendor/github.com/emersion/go-message/multipart.go
+++ b/vendor/github.com/emersion/go-message/multipart.go
@@ -0,0 +1,116 @@
+package message
+
+import (
+	"io"
+
+	"github.com/emersion/go-message/textproto"
+)
+
+// MultipartReader is an iterator over parts in a MIME multipart body.
+type MultipartReader interface {
+	io.Closer
+
+	// NextPart returns the next part in the multipart or an error. When there are
+	// no more parts, the error io.EOF is returned.
+	//
+	// Entity.Body must be read completely before the next call to NextPart,
+	// otherwise it will be discarded.
+	NextPart() (*Entity, error)
+}
+
+type multipartReader struct {
+	r *textproto.MultipartReader
+}
+
+// NextPart implements MultipartReader.
+func (r *multipartReader) NextPart() (*Entity, error) {
+	p, err := r.r.NextPart()
+	if err != nil {
+		return nil, err
+	}
+	return New(Header{p.Header}, p)
+}
+
+// Close implements io.Closer.
+func (r *multipartReader) Close() error {
+	return nil
+}
+
+type multipartBody struct {
+	header Header
+	parts  []*Entity
+
+	r *io.PipeReader
+	w *Writer
+
+	i int
+}
+
+// Read implements io.Reader.
+func (m *multipartBody) Read(p []byte) (n int, err error) {
+	if m.r == nil {
+		r, w := io.Pipe()
+		m.r = r
+
+		var err error
+		m.w, err = createWriter(w, &m.header)
+		if err != nil {
+			return 0, err
+		}
+
+		// Prevent calls to NextPart to succeed
+		m.i = len(m.parts)
+
+		go func() {
+			if err := m.writeBodyTo(m.w); err != nil {
+				w.CloseWithError(err)
+				return
+			}
+
+			if err := m.w.Close(); err != nil {
+				w.CloseWithError(err)
+				return
+			}
+
+			w.Close()
+		}()
+	}
+
+	return m.r.Read(p)
+}
+
+// Close implements io.Closer.
+func (m *multipartBody) Close() error {
+	if m.r != nil {
+		m.r.Close()
+	}
+	return nil
+}
+
+// NextPart implements MultipartReader.
+func (m *multipartBody) NextPart() (*Entity, error) {
+	if m.i >= len(m.parts) {
+		return nil, io.EOF
+	}
+
+	part := m.parts[m.i]
+	m.i++
+	return part, nil
+}
+
+func (m *multipartBody) writeBodyTo(w *Writer) error {
+	for _, p := range m.parts {
+		pw, err := w.CreatePart(p.Header)
+		if err != nil {
+			return err
+		}
+
+		if err := p.writeBodyTo(pw); err != nil {
+			return err
+		}
+		if err := pw.Close(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
--- a/vendor/github.com/emersion/go-message/textproto/header.go
+++ b/vendor/github.com/emersion/go-message/textproto/header.go
@@ -0,0 +1,677 @@
+package textproto
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"net/textproto"
+	"sort"
+	"strings"
+)
+
+type headerField struct {
+	b []byte // Raw header field, including whitespace
+
+	k string
+	v string
+}
+
+func newHeaderField(k, v string, b []byte) *headerField {
+	return &headerField{k: textproto.CanonicalMIMEHeaderKey(k), v: v, b: b}
+}
+
+func (f *headerField) raw() ([]byte, error) {
+	if f.b != nil {
+		return f.b, nil
+	} else {
+		for pos, ch := range f.k {
+			// check if character is a printable US-ASCII except ':'
+			if !(ch >= '!' && ch < ':' || ch > ':' && ch <= '~') {
+				return nil, fmt.Errorf("field name contains incorrect symbols (\\x%x at %v)", ch, pos)
+			}
+		}
+
+		if pos := strings.IndexAny(f.v, "\r\n"); pos != -1 {
+			return nil, fmt.Errorf("field value contains \\r\\n (at %v)", pos)
+		}
+
+		return []byte(formatHeaderField(f.k, f.v)), nil
+	}
+}
+
+// A Header represents the key-value pairs in a message header.
+//
+// The header representation is idempotent: if the header can be read and
+// written, the result will be exactly the same as the original (including
+// whitespace and header field ordering). This is required for e.g. DKIM.
+//
+// Mutating the header is restricted: the only two allowed operations are
+// inserting a new header field at the top and deleting a header field. This is
+// again necessary for DKIM.
+type Header struct {
+	// Fields are in reverse order so that inserting a new field at the top is
+	// cheap.
+	l []*headerField
+	m map[string][]*headerField
+}
+
+func makeHeaderMap(fs []*headerField) map[string][]*headerField {
+	if len(fs) == 0 {
+		return nil
+	}
+
+	m := make(map[string][]*headerField, len(fs))
+	for i, f := range fs {
+		m[f.k] = append(m[f.k], fs[i])
+	}
+	return m
+}
+
+func newHeader(fs []*headerField) Header {
+	// Reverse order
+	for i := len(fs)/2 - 1; i >= 0; i-- {
+		opp := len(fs) - 1 - i
+		fs[i], fs[opp] = fs[opp], fs[i]
+	}
+
+	return Header{l: fs, m: makeHeaderMap(fs)}
+}
+
+// HeaderFromMap creates a header from a map of header fields.
+//
+// This function is provided for interoperability with the standard library.
+// If possible, ReadHeader should be used instead to avoid loosing information.
+// The map representation looses the ordering of the fields, the capitalization
+// of the header keys, and the whitespace of the original header.
+func HeaderFromMap(m map[string][]string) Header {
+	fs := make([]*headerField, 0, len(m))
+	for k, vs := range m {
+		for _, v := range vs {
+			fs = append(fs, newHeaderField(k, v, nil))
+		}
+	}
+
+	sort.SliceStable(fs, func(i, j int) bool {
+		return fs[i].k < fs[j].k
+	})
+
+	return newHeader(fs)
+}
+
+// AddRaw adds the raw key, value pair to the header.
+//
+// The supplied byte slice should be a complete field in the "Key: Value" form
+// including trailing CRLF. If there is no comma in the input - AddRaw panics.
+// No changes are made to kv contents and it will be copied into WriteHeader
+// output as is.
+//
+// kv is directly added to the underlying structure and therefore should not be
+// modified after the AddRaw call.
+func (h *Header) AddRaw(kv []byte) {
+	colon := bytes.IndexByte(kv, ':')
+	if colon == -1 {
+		panic("textproto: Header.AddRaw: missing colon")
+	}
+	k := textproto.CanonicalMIMEHeaderKey(string(trim(kv[:colon])))
+	v := trimAroundNewlines(kv[colon+1:])
+
+	if h.m == nil {
+		h.m = make(map[string][]*headerField)
+	}
+
+	f := newHeaderField(k, v, kv)
+	h.l = append(h.l, f)
+	h.m[k] = append(h.m[k], f)
+}
+
+// Add adds the key, value pair to the header. It prepends to any existing
+// fields associated with key.
+//
+// Key and value should obey character requirements of RFC 6532.
+// If you need to format or fold lines manually, use AddRaw.
+func (h *Header) Add(k, v string) {
+	k = textproto.CanonicalMIMEHeaderKey(k)
+
+	if h.m == nil {
+		h.m = make(map[string][]*headerField)
+	}
+
+	f := newHeaderField(k, v, nil)
+	h.l = append(h.l, f)
+	h.m[k] = append(h.m[k], f)
+}
+
+// Get gets the first value associated with the given key. If there are no
+// values associated with the key, Get returns "".
+func (h *Header) Get(k string) string {
+	fields := h.m[textproto.CanonicalMIMEHeaderKey(k)]
+	if len(fields) == 0 {
+		return ""
+	}
+	return fields[len(fields)-1].v
+}
+
+// Raw gets the first raw header field associated with the given key.
+//
+// The returned bytes contain a complete field in the "Key: value" form,
+// including trailing CRLF.
+//
+// The returned slice should not be modified and becomes invalid when the
+// header is updated.
+//
+// An error is returned if the header field contains incorrect characters (see
+// RFC 6532).
+func (h *Header) Raw(k string) ([]byte, error) {
+	fields := h.m[textproto.CanonicalMIMEHeaderKey(k)]
+	if len(fields) == 0 {
+		return nil, nil
+	}
+	return fields[len(fields)-1].raw()
+}
+
+// Values returns all values associated with the given key.
+//
+// The returned slice should not be modified and becomes invalid when the
+// header is updated.
+func (h *Header) Values(k string) []string {
+	fields := h.m[textproto.CanonicalMIMEHeaderKey(k)]
+	if len(fields) == 0 {
+		return nil
+	}
+	l := make([]string, len(fields))
+	for i, field := range fields {
+		l[len(fields)-i-1] = field.v
+	}
+	return l
+}
+
+// Set sets the header fields associated with key to the single field value.
+// It replaces any existing values associated with key.
+func (h *Header) Set(k, v string) {
+	h.Del(k)
+	h.Add(k, v)
+}
+
+// Del deletes the values associated with key.
+func (h *Header) Del(k string) {
+	k = textproto.CanonicalMIMEHeaderKey(k)
+
+	delete(h.m, k)
+
+	// Delete existing keys
+	for i := len(h.l) - 1; i >= 0; i-- {
+		if h.l[i].k == k {
+			h.l = append(h.l[:i], h.l[i+1:]...)
+		}
+	}
+}
+
+// Has checks whether the header has a field with the specified key.
+func (h *Header) Has(k string) bool {
+	_, ok := h.m[textproto.CanonicalMIMEHeaderKey(k)]
+	return ok
+}
+
+// Copy creates an independent copy of the header.
+func (h *Header) Copy() Header {
+	l := make([]*headerField, len(h.l))
+	copy(l, h.l)
+	m := makeHeaderMap(l)
+	return Header{l: l, m: m}
+}
+
+// Len returns the number of fields in the header.
+func (h *Header) Len() int {
+	return len(h.l)
+}
+
+// Map returns all header fields as a map.
+//
+// This function is provided for interoperability with the standard library.
+// If possible, Fields should be used instead to avoid loosing information.
+// The map representation looses the ordering of the fields, the capitalization
+// of the header keys, and the whitespace of the original header.
+func (h *Header) Map() map[string][]string {
+	m := make(map[string][]string, h.Len())
+	fields := h.Fields()
+	for fields.Next() {
+		m[fields.Key()] = append(m[fields.Key()], fields.Value())
+	}
+	return m
+}
+
+// HeaderFields iterates over header fields. Its cursor starts before the first
+// field of the header. Use Next to advance from field to field.
+type HeaderFields interface {
+	// Next advances to the next header field. It returns true on success, or
+	// false if there is no next field.
+	Next() (more bool)
+	// Key returns the key of the current field.
+	Key() string
+	// Value returns the value of the current field.
+	Value() string
+	// Raw returns the raw current header field. See Header.Raw.
+	Raw() ([]byte, error)
+	// Del deletes the current field.
+	Del()
+	// Len returns the amount of header fields in the subset of header iterated
+	// by this HeaderFields instance.
+	//
+	// For Fields(), it will return the amount of fields in the whole header section.
+	// For FieldsByKey(), it will return the amount of fields with certain key.
+	Len() int
+}
+
+type headerFields struct {
+	h   *Header
+	cur int
+}
+
+func (fs *headerFields) Next() bool {
+	fs.cur++
+	return fs.cur < len(fs.h.l)
+}
+
+func (fs *headerFields) index() int {
+	if fs.cur < 0 {
+		panic("message: HeaderFields method called before Next")
+	}
+	if fs.cur >= len(fs.h.l) {
+		panic("message: HeaderFields method called after Next returned false")
+	}
+	return len(fs.h.l) - fs.cur - 1
+}
+
+func (fs *headerFields) field() *headerField {
+	return fs.h.l[fs.index()]
+}
+
+func (fs *headerFields) Key() string {
+	return fs.field().k
+}
+
+func (fs *headerFields) Value() string {
+	return fs.field().v
+}
+
+func (fs *headerFields) Raw() ([]byte, error) {
+	return fs.field().raw()
+}
+
+func (fs *headerFields) Del() {
+	f := fs.field()
+
+	ok := false
+	for i, ff := range fs.h.m[f.k] {
+		if ff == f {
+			ok = true
+			fs.h.m[f.k] = append(fs.h.m[f.k][:i], fs.h.m[f.k][i+1:]...)
+			if len(fs.h.m[f.k]) == 0 {
+				delete(fs.h.m, f.k)
+			}
+			break
+		}
+	}
+	if !ok {
+		panic("message: field not found in Header.m")
+	}
+
+	fs.h.l = append(fs.h.l[:fs.index()], fs.h.l[fs.index()+1:]...)
+	fs.cur--
+}
+
+func (fs *headerFields) Len() int {
+	return len(fs.h.l)
+}
+
+// Fields iterates over all the header fields.
+//
+// The header may not be mutated while iterating, except using HeaderFields.Del.
+func (h *Header) Fields() HeaderFields {
+	return &headerFields{h, -1}
+}
+
+type headerFieldsByKey struct {
+	h   *Header
+	k   string
+	cur int
+}
+
+func (fs *headerFieldsByKey) Next() bool {
+	fs.cur++
+	return fs.cur < len(fs.h.m[fs.k])
+}
+
+func (fs *headerFieldsByKey) index() int {
+	if fs.cur < 0 {
+		panic("message: headerfields.key or value called before next")
+	}
+	if fs.cur >= len(fs.h.m[fs.k]) {
+		panic("message: headerfields.key or value called after next returned false")
+	}
+	return len(fs.h.m[fs.k]) - fs.cur - 1
+}
+
+func (fs *headerFieldsByKey) field() *headerField {
+	return fs.h.m[fs.k][fs.index()]
+}
+
+func (fs *headerFieldsByKey) Key() string {
+	return fs.field().k
+}
+
+func (fs *headerFieldsByKey) Value() string {
+	return fs.field().v
+}
+
+func (fs *headerFieldsByKey) Raw() ([]byte, error) {
+	return fs.field().raw()
+}
+
+func (fs *headerFieldsByKey) Del() {
+	f := fs.field()
+
+	ok := false
+	for i := range fs.h.l {
+		if f == fs.h.l[i] {
+			ok = true
+			fs.h.l = append(fs.h.l[:i], fs.h.l[i+1:]...)
+			break
+		}
+	}
+	if !ok {
+		panic("message: field not found in Header.l")
+	}
+
+	fs.h.m[fs.k] = append(fs.h.m[fs.k][:fs.index()], fs.h.m[fs.k][fs.index()+1:]...)
+	if len(fs.h.m[fs.k]) == 0 {
+		delete(fs.h.m, fs.k)
+	}
+	fs.cur--
+}
+
+func (fs *headerFieldsByKey) Len() int {
+	return len(fs.h.m[fs.k])
+}
+
+// FieldsByKey iterates over all fields having the specified key.
+//
+// The header may not be mutated while iterating, except using HeaderFields.Del.
+func (h *Header) FieldsByKey(k string) HeaderFields {
+	return &headerFieldsByKey{h, textproto.CanonicalMIMEHeaderKey(k), -1}
+}
+
+func readLineSlice(r *bufio.Reader, line []byte) ([]byte, error) {
+	for {
+		l, more, err := r.ReadLine()
+		line = append(line, l...)
+		if err != nil {
+			return line, err
+		}
+
+		if !more {
+			break
+		}
+	}
+
+	return line, nil
+}
+
+func isSpace(c byte) bool {
+	return c == ' ' || c == '\t'
+}
+
+func validHeaderKeyByte(b byte) bool {
+	c := int(b)
+	return c >= 33 && c <= 126 && c != ':'
+}
+
+// trim returns s with leading and trailing spaces and tabs removed.
+// It does not assume Unicode or UTF-8.
+func trim(s []byte) []byte {
+	i := 0
+	for i < len(s) && isSpace(s[i]) {
+		i++
+	}
+	n := len(s)
+	for n > i && isSpace(s[n-1]) {
+		n--
+	}
+	return s[i:n]
+}
+
+func hasContinuationLine(r *bufio.Reader) bool {
+	c, err := r.ReadByte()
+	if err != nil {
+		return false // bufio will keep err until next read.
+	}
+	r.UnreadByte()
+	return isSpace(c)
+}
+
+func readContinuedLineSlice(r *bufio.Reader) ([]byte, error) {
+	// Read the first line. We preallocate slice that it enough
+	// for most fields.
+	line, err := readLineSlice(r, make([]byte, 0, 256))
+	if err == io.EOF && len(line) == 0 {
+		// Header without a body
+		return nil, nil
+	} else if err != nil {
+		return nil, err
+	}
+
+	if len(line) == 0 { // blank line - no continuation
+		return line, nil
+	}
+
+	line = append(line, '\r', '\n')
+
+	// Read continuation lines.
+	for hasContinuationLine(r) {
+		line, err = readLineSlice(r, line)
+		if err != nil {
+			break // bufio will keep err until next read.
+		}
+
+		line = append(line, '\r', '\n')
+	}
+
+	return line, nil
+}
+
+func writeContinued(b *strings.Builder, l []byte) {
+	// Strip trailing \r, if any
+	if len(l) > 0 && l[len(l)-1] == '\r' {
+		l = l[:len(l)-1]
+	}
+	l = trim(l)
+	if len(l) == 0 {
+		return
+	}
+	if b.Len() > 0 {
+		b.WriteByte(' ')
+	}
+	b.Write(l)
+}
+
+// Strip newlines and spaces around newlines.
+func trimAroundNewlines(v []byte) string {
+	var b strings.Builder
+	b.Grow(len(v))
+	for {
+		i := bytes.IndexByte(v, '\n')
+		if i < 0 {
+			writeContinued(&b, v)
+			break
+		}
+		writeContinued(&b, v[:i])
+		v = v[i+1:]
+	}
+
+	return b.String()
+}
+
+// ReadHeader reads a MIME header from r. The header is a sequence of possibly
+// continued "Key: Value" lines ending in a blank line.
+//
+// To avoid denial of service attacks, the provided bufio.Reader should be
+// reading from an io.LimitedReader or a similar Reader to bound the size of
+// headers.
+func ReadHeader(r *bufio.Reader) (Header, error) {
+	fs := make([]*headerField, 0, 32)
+
+	// The first line cannot start with a leading space.
+	if buf, err := r.Peek(1); err == nil && isSpace(buf[0]) {
+		line, err := readLineSlice(r, nil)
+		if err != nil {
+			return newHeader(fs), err
+		}
+
+		return newHeader(fs), fmt.Errorf("message: malformed MIME header initial line: %v", string(line))
+	}
+
+	for {
+		kv, err := readContinuedLineSlice(r)
+		if len(kv) == 0 {
+			return newHeader(fs), err
+		}
+
+		// Key ends at first colon; should not have trailing spaces but they
+		// appear in the wild, violating specs, so we remove them if present.
+		i := bytes.IndexByte(kv, ':')
+		if i < 0 {
+			return newHeader(fs), fmt.Errorf("message: malformed MIME header line: %v", string(kv))
+		}
+
+		keyBytes := trim(kv[:i])
+
+		// Verify that there are no invalid characters in the header key.
+		// See RFC 5322 Section 2.2
+		for _, c := range keyBytes {
+			if !validHeaderKeyByte(c) {
+				return newHeader(fs), fmt.Errorf("message: malformed MIME header key: %v", string(keyBytes))
+			}
+		}
+
+		key := textproto.CanonicalMIMEHeaderKey(string(keyBytes))
+
+		// As per RFC 7230 field-name is a token, tokens consist of one or more
+		// chars. We could return a an error here, but better to be liberal in
+		// what we accept, so if we get an empty key, skip it.
+		if key == "" {
+			continue
+		}
+
+		i++ // skip colon
+		v := kv[i:]
+
+		value := trimAroundNewlines(v)
+		fs = append(fs, newHeaderField(key, value, kv))
+
+		if err != nil {
+			return newHeader(fs), err
+		}
+	}
+}
+
+func foldLine(v string, maxlen int) (line, next string, ok bool) {
+	ok = true
+
+	// We'll need to fold before maxlen
+	foldBefore := maxlen + 1
+	foldAt := len(v)
+
+	var folding string
+	if foldBefore > len(v) {
+		// We reached the end of the string
+		if v[len(v)-1] != '\n' {
+			// If there isn't already a trailing CRLF, insert one
+			folding = "\r\n"
+		}
+	} else {
+		// Find the closest whitespace before maxlen
+		foldAt = strings.LastIndexAny(v[:foldBefore], " \t\n")
+
+		if foldAt == 0 {
+			// The whitespace we found was the previous folding WSP
+			foldAt = foldBefore - 1
+		} else if foldAt < 0 {
+			// We didn't find any whitespace, we have to insert one
+			foldAt = foldBefore - 2
+		}
+
+		switch v[foldAt] {
+		case ' ', '\t':
+			if v[foldAt-1] != '\n' {
+				folding = "\r\n" // The next char will be a WSP, don't need to insert one
+			}
+		case '\n':
+			folding = "" // There is already a CRLF, nothing to do
+		default:
+			// Another char, we need to insert CRLF + WSP. This will insert an
+			// extra space in the string, so this should be avoided if
+			// possible.
+			folding = "\r\n "
+			ok = false
+		}
+	}
+
+	return v[:foldAt] + folding, v[foldAt:], ok
+}
+
+const (
+	preferredHeaderLen = 76
+	maxHeaderLen       = 998
+)
+
+// formatHeaderField formats a header field, ensuring each line is no longer
+// than 76 characters. It tries to fold lines at whitespace characters if
+// possible. If the header contains a word longer than this limit, it will be
+// split.
+func formatHeaderField(k, v string) string {
+	s := k + ": "
+
+	if v == "" {
+		return s + "\r\n"
+	}
+
+	first := true
+	for len(v) > 0 {
+		// If this is the first line, substract the length of the key
+		keylen := 0
+		if first {
+			keylen = len(s)
+		}
+
+		// First try with a soft limit
+		l, next, ok := foldLine(v, preferredHeaderLen-keylen)
+		if !ok {
+			// Folding failed to preserve the original header field value. Try
+			// with a larger, hard limit.
+			l, next, _ = foldLine(v, maxHeaderLen-keylen)
+		}
+		v = next
+		s += l
+		first = false
+	}
+
+	return s
+}
+
+// WriteHeader writes a MIME header to w.
+func WriteHeader(w io.Writer, h Header) error {
+	for i := len(h.l) - 1; i >= 0; i-- {
+		f := h.l[i]
+		if rawField, err := f.raw(); err == nil {
+			if _, err := w.Write(rawField); err != nil {
+				return err
+			}
+		} else {
+			return fmt.Errorf("failed to write header field #%v (%q): %w", len(h.l)-i, f.k, err)
+		}
+	}
+
+	_, err := w.Write([]byte{'\r', '\n'})
+	return err
+}
--- a/vendor/github.com/emersion/go-message/textproto/multipart.go
+++ b/vendor/github.com/emersion/go-message/textproto/multipart.go
@@ -0,0 +1,473 @@
+// Copyright 2010 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 textproto
+
+// Multipart is defined in RFC 2046.
+
+import (
+	"bufio"
+	"bytes"
+	"crypto/rand"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+)
+
+var emptyParams = make(map[string]string)
+
+// This constant needs to be at least 76 for this package to work correctly.
+// This is because \r\n--separator_of_len_70- would fill the buffer and it
+// wouldn't be safe to consume a single byte from it.
+const peekBufferSize = 4096
+
+// A Part represents a single part in a multipart body.
+type Part struct {
+	Header Header
+
+	mr *MultipartReader
+
+	// r is either a reader directly reading from mr
+	r io.Reader
+
+	n       int   // known data bytes waiting in mr.bufReader
+	total   int64 // total data bytes read already
+	err     error // error to return when n == 0
+	readErr error // read error observed from mr.bufReader
+}
+
+// NewMultipartReader creates a new multipart reader reading from r using the
+// given MIME boundary.
+//
+// The boundary is usually obtained from the "boundary" parameter of
+// the message's "Content-Type" header. Use mime.ParseMediaType to
+// parse such headers.
+func NewMultipartReader(r io.Reader, boundary string) *MultipartReader {
+	b := []byte("\r\n--" + boundary + "--")
+	return &MultipartReader{
+		bufReader:        bufio.NewReaderSize(&stickyErrorReader{r: r}, peekBufferSize),
+		nl:               b[:2],
+		nlDashBoundary:   b[:len(b)-2],
+		dashBoundaryDash: b[2:],
+		dashBoundary:     b[2 : len(b)-2],
+	}
+}
+
+// stickyErrorReader is an io.Reader which never calls Read on its
+// underlying Reader once an error has been seen. (the io.Reader
+// interface's contract promises nothing about the return values of
+// Read calls after an error, yet this package does do multiple Reads
+// after error)
+type stickyErrorReader struct {
+	r   io.Reader
+	err error
+}
+
+func (r *stickyErrorReader) Read(p []byte) (n int, _ error) {
+	if r.err != nil {
+		return 0, r.err
+	}
+	n, r.err = r.r.Read(p)
+	return n, r.err
+}
+
+func newPart(mr *MultipartReader) (*Part, error) {
+	bp := &Part{mr: mr}
+	if err := bp.populateHeaders(); err != nil {
+		return nil, err
+	}
+	bp.r = partReader{bp}
+	return bp, nil
+}
+
+func (bp *Part) populateHeaders() error {
+	header, err := ReadHeader(bp.mr.bufReader)
+	if err == nil {
+		bp.Header = header
+	}
+	return err
+}
+
+// Read reads the body of a part, after its headers and before the
+// next part (if any) begins.
+func (p *Part) Read(d []byte) (n int, err error) {
+	return p.r.Read(d)
+}
+
+// partReader implements io.Reader by reading raw bytes directly from the
+// wrapped *Part, without doing any Transfer-Encoding decoding.
+type partReader struct {
+	p *Part
+}
+
+func (pr partReader) Read(d []byte) (int, error) {
+	p := pr.p
+	br := p.mr.bufReader
+
+	// Read into buffer until we identify some data to return,
+	// or we find a reason to stop (boundary or read error).
+	for p.n == 0 && p.err == nil {
+		peek, _ := br.Peek(br.Buffered())
+		p.n, p.err = scanUntilBoundary(peek, p.mr.dashBoundary, p.mr.nlDashBoundary, p.total, p.readErr)
+		if p.n == 0 && p.err == nil {
+			// Force buffered I/O to read more into buffer.
+			_, p.readErr = br.Peek(len(peek) + 1)
+			if p.readErr == io.EOF {
+				p.readErr = io.ErrUnexpectedEOF
+			}
+		}
+	}
+
+	// Read out from "data to return" part of buffer.
+	if p.n == 0 {
+		return 0, p.err
+	}
+	n := len(d)
+	if n > p.n {
+		n = p.n
+	}
+	n, _ = br.Read(d[:n])
+	p.total += int64(n)
+	p.n -= n
+	if p.n == 0 {
+		return n, p.err
+	}
+	return n, nil
+}
+
+// scanUntilBoundary scans buf to identify how much of it can be safely
+// returned as part of the Part body.
+// dashBoundary is "--boundary".
+// nlDashBoundary is "\r\n--boundary" or "\n--boundary", depending on what mode we are in.
+// The comments below (and the name) assume "\n--boundary", but either is accepted.
+// total is the number of bytes read out so far. If total == 0, then a leading "--boundary" is recognized.
+// readErr is the read error, if any, that followed reading the bytes in buf.
+// scanUntilBoundary returns the number of data bytes from buf that can be
+// returned as part of the Part body and also the error to return (if any)
+// once those data bytes are done.
+func scanUntilBoundary(buf, dashBoundary, nlDashBoundary []byte, total int64, readErr error) (int, error) {
+	if total == 0 {
+		// At beginning of body, allow dashBoundary.
+		if bytes.HasPrefix(buf, dashBoundary) {
+			switch matchAfterPrefix(buf, dashBoundary, readErr) {
+			case -1:
+				return len(dashBoundary), nil
+			case 0:
+				return 0, nil
+			case +1:
+				return 0, io.EOF
+			}
+		}
+		if bytes.HasPrefix(dashBoundary, buf) {
+			return 0, readErr
+		}
+	}
+
+	// Search for "\n--boundary".
+	if i := bytes.Index(buf, nlDashBoundary); i >= 0 {
+		switch matchAfterPrefix(buf[i:], nlDashBoundary, readErr) {
+		case -1:
+			return i + len(nlDashBoundary), nil
+		case 0:
+			return i, nil
+		case +1:
+			return i, io.EOF
+		}
+	}
+	if bytes.HasPrefix(nlDashBoundary, buf) {
+		return 0, readErr
+	}
+
+	// Otherwise, anything up to the final \n is not part of the boundary
+	// and so must be part of the body.
+	// Also if the section from the final \n onward is not a prefix of the boundary,
+	// it too must be part of the body.
+	i := bytes.LastIndexByte(buf, nlDashBoundary[0])
+	if i >= 0 && bytes.HasPrefix(nlDashBoundary, buf[i:]) {
+		return i, nil
+	}
+	return len(buf), readErr
+}
+
+// matchAfterPrefix checks whether buf should be considered to match the boundary.
+// The prefix is "--boundary" or "\r\n--boundary" or "\n--boundary",
+// and the caller has verified already that bytes.HasPrefix(buf, prefix) is true.
+//
+// matchAfterPrefix returns +1 if the buffer does match the boundary,
+// meaning the prefix is followed by a dash, space, tab, cr, nl, or end of input.
+// It returns -1 if the buffer definitely does NOT match the boundary,
+// meaning the prefix is followed by some other character.
+// For example, "--foobar" does not match "--foo".
+// It returns 0 more input needs to be read to make the decision,
+// meaning that len(buf) == len(prefix) and readErr == nil.
+func matchAfterPrefix(buf, prefix []byte, readErr error) int {
+	if len(buf) == len(prefix) {
+		if readErr != nil {
+			return +1
+		}
+		return 0
+	}
+	c := buf[len(prefix)]
+	if c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '-' {
+		return +1
+	}
+	return -1
+}
+
+func (p *Part) Close() error {
+	io.Copy(ioutil.Discard, p)
+	return nil
+}
+
+// MultipartReader is an iterator over parts in a MIME multipart body.
+// MultipartReader's underlying parser consumes its input as needed. Seeking
+// isn't supported.
+type MultipartReader struct {
+	bufReader *bufio.Reader
+
+	currentPart *Part
+	partsRead   int
+
+	nl               []byte // "\r\n" or "\n" (set after seeing first boundary line)
+	nlDashBoundary   []byte // nl + "--boundary"
+	dashBoundaryDash []byte // "--boundary--"
+	dashBoundary     []byte // "--boundary"
+}
+
+// NextPart returns the next part in the multipart or an error.
+// When there are no more parts, the error io.EOF is returned.
+func (r *MultipartReader) NextPart() (*Part, error) {
+	if r.currentPart != nil {
+		r.currentPart.Close()
+	}
+	if string(r.dashBoundary) == "--" {
+		return nil, fmt.Errorf("multipart: boundary is empty")
+	}
+	expectNewPart := false
+	for {
+		line, err := r.bufReader.ReadSlice('\n')
+
+		if err == io.EOF && r.isFinalBoundary(line) {
+			// If the buffer ends in "--boundary--" without the
+			// trailing "\r\n", ReadSlice will return an error
+			// (since it's missing the '\n'), but this is a valid
+			// multipart EOF so we need to return io.EOF instead of
+			// a fmt-wrapped one.
+			return nil, io.EOF
+		}
+		if err != nil {
+			return nil, fmt.Errorf("multipart: NextPart: %v", err)
+		}
+
+		if r.isBoundaryDelimiterLine(line) {
+			r.partsRead++
+			bp, err := newPart(r)
+			if err != nil {
+				return nil, err
+			}
+			r.currentPart = bp
+			return bp, nil
+		}
+
+		if r.isFinalBoundary(line) {
+			// Expected EOF
+			return nil, io.EOF
+		}
+
+		if expectNewPart {
+			return nil, fmt.Errorf("multipart: expecting a new Part; got line %q", string(line))
+		}
+
+		if r.partsRead == 0 {
+			// skip line
+			continue
+		}
+
+		// Consume the "\n" or "\r\n" separator between the
+		// body of the previous part and the boundary line we
+		// now expect will follow. (either a new part or the
+		// end boundary)
+		if bytes.Equal(line, r.nl) {
+			expectNewPart = true
+			continue
+		}
+
+		return nil, fmt.Errorf("multipart: unexpected line in Next(): %q", line)
+	}
+}
+
+// isFinalBoundary reports whether line is the final boundary line
+// indicating that all parts are over.
+// It matches `^--boundary--[ \t]*(\r\n)?$`
+func (mr *MultipartReader) isFinalBoundary(line []byte) bool {
+	if !bytes.HasPrefix(line, mr.dashBoundaryDash) {
+		return false
+	}
+	rest := line[len(mr.dashBoundaryDash):]
+	rest = skipLWSPChar(rest)
+	return len(rest) == 0 || bytes.Equal(rest, mr.nl)
+}
+
+func (mr *MultipartReader) isBoundaryDelimiterLine(line []byte) (ret bool) {
+	// https://tools.ietf.org/html/rfc2046#section-5.1
+	//   The boundary delimiter line is then defined as a line
+	//   consisting entirely of two hyphen characters ("-",
+	//   decimal value 45) followed by the boundary parameter
+	//   value from the Content-Type header field, optional linear
+	//   whitespace, and a terminating CRLF.
+	if !bytes.HasPrefix(line, mr.dashBoundary) {
+		return false
+	}
+	rest := line[len(mr.dashBoundary):]
+	rest = skipLWSPChar(rest)
+
+	// On the first part, see our lines are ending in \n instead of \r\n
+	// and switch into that mode if so. This is a violation of the spec,
+	// but occurs in practice.
+	if mr.partsRead == 0 && len(rest) == 1 && rest[0] == '\n' {
+		mr.nl = mr.nl[1:]
+		mr.nlDashBoundary = mr.nlDashBoundary[1:]
+	}
+	return bytes.Equal(rest, mr.nl)
+}
+
+// skipLWSPChar returns b with leading spaces and tabs removed.
+// RFC 822 defines:
+//    LWSP-char = SPACE / HTAB
+func skipLWSPChar(b []byte) []byte {
+	for len(b) > 0 && (b[0] == ' ' || b[0] == '\t') {
+		b = b[1:]
+	}
+	return b
+}
+
+// A MultipartWriter generates multipart messages.
+type MultipartWriter struct {
+	w        io.Writer
+	boundary string
+	lastpart *part
+}
+
+// NewMultipartWriter returns a new multipart Writer with a random boundary,
+// writing to w.
+func NewMultipartWriter(w io.Writer) *MultipartWriter {
+	return &MultipartWriter{
+		w:        w,
+		boundary: randomBoundary(),
+	}
+}
+
+// Boundary returns the Writer's boundary.
+func (w *MultipartWriter) Boundary() string {
+	return w.boundary
+}
+
+// SetBoundary overrides the Writer's default randomly-generated
+// boundary separator with an explicit value.
+//
+// SetBoundary must be called before any parts are created, may only
+// contain certain ASCII characters, and must be non-empty and
+// at most 70 bytes long.
+func (w *MultipartWriter) SetBoundary(boundary string) error {
+	if w.lastpart != nil {
+		return errors.New("mime: SetBoundary called after write")
+	}
+	// rfc2046#section-5.1.1
+	if len(boundary) < 1 || len(boundary) > 70 {
+		return errors.New("mime: invalid boundary length")
+	}
+	end := len(boundary) - 1
+	for i, b := range boundary {
+		if 'A' <= b && b <= 'Z' || 'a' <= b && b <= 'z' || '0' <= b && b <= '9' {
+			continue
+		}
+		switch b {
+		case '\'', '(', ')', '+', '_', ',', '-', '.', '/', ':', '=', '?':
+			continue
+		case ' ':
+			if i != end {
+				continue
+			}
+		}
+		return errors.New("mime: invalid boundary character")
+	}
+	w.boundary = boundary
+	return nil
+}
+
+func randomBoundary() string {
+	var buf [30]byte
+	_, err := io.ReadFull(rand.Reader, buf[:])
+	if err != nil {
+		panic(err)
+	}
+	return fmt.Sprintf("%x", buf[:])
+}
+
+// CreatePart creates a new multipart section with the provided
+// header. The body of the part should be written to the returned
+// Writer. After calling CreatePart, any previous part may no longer
+// be written to.
+func (w *MultipartWriter) CreatePart(header Header) (io.Writer, error) {
+	if w.lastpart != nil {
+		if err := w.lastpart.close(); err != nil {
+			return nil, err
+		}
+	}
+	var b bytes.Buffer
+	if w.lastpart != nil {
+		fmt.Fprintf(&b, "\r\n--%s\r\n", w.boundary)
+	} else {
+		fmt.Fprintf(&b, "--%s\r\n", w.boundary)
+	}
+
+	WriteHeader(&b, header)
+
+	_, err := io.Copy(w.w, &b)
+	if err != nil {
+		return nil, err
+	}
+	p := &part{
+		mw: w,
+	}
+	w.lastpart = p
+	return p, nil
+}
+
+// Close finishes the multipart message and writes the trailing
+// boundary end line to the output.
+func (w *MultipartWriter) Close() error {
+	if w.lastpart != nil {
+		if err := w.lastpart.close(); err != nil {
+			return err
+		}
+		w.lastpart = nil
+	}
+	_, err := fmt.Fprintf(w.w, "\r\n--%s--\r\n", w.boundary)
+	return err
+}
+
+type part struct {
+	mw     *MultipartWriter
+	closed bool
+	we     error // last error that occurred writing
+}
+
+func (p *part) close() error {
+	p.closed = true
+	return p.we
+}
+
+func (p *part) Write(d []byte) (n int, err error) {
+	if p.closed {
+		return 0, errors.New("multipart: can't write to finished part")
+	}
+	n, err = p.mw.w.Write(d)
+	if err != nil {
+		p.we = err
+	}
+	return
+}
--- a/vendor/github.com/emersion/go-message/textproto/textproto.go
+++ b/vendor/github.com/emersion/go-message/textproto/textproto.go
@@ -0,0 +1,2 @@
+// Package textproto implements low-level manipulation of MIME messages.
+package textproto
--- a/Show More
+++ b/Show More