Compare commits
No commits in common. "b65f60b1632c45907f2e051e1b9ceeba64c56526" and "6ea1c86967dca0f5fc6f2f052de0972bc6894dc5" have entirely different histories.
b65f60b163
...
6ea1c86967
|
@ -60,7 +60,7 @@ bypass the verification of the server's certificate chain and host name by using
|
|||
)
|
||||
|
||||
func main() {
|
||||
d := gomail.NewDialer("smtp.example.com", 587, "user", "123456")
|
||||
d := gomail.NewPlainDialer("smtp.example.com", 587, "user", "123456")
|
||||
d.TLSConfig = &tls.Config{InsecureSkipVerify: true}
|
||||
|
||||
// Send emails using d.
|
||||
|
|
50
auth.go
50
auth.go
|
@ -7,33 +7,51 @@ import (
|
|||
"net/smtp"
|
||||
)
|
||||
|
||||
// loginAuth is an smtp.Auth that implements the LOGIN authentication mechanism.
|
||||
type loginAuth struct {
|
||||
// plainAuth is an smtp.Auth that implements the PLAIN authentication mechanism.
|
||||
// It fallbacks to the LOGIN mechanism if it is the only mechanism advertised
|
||||
// by the server.
|
||||
type plainAuth struct {
|
||||
username string
|
||||
password string
|
||||
host string
|
||||
login bool
|
||||
}
|
||||
|
||||
func (a *loginAuth) Start(server *smtp.ServerInfo) (string, []byte, error) {
|
||||
if !server.TLS {
|
||||
advertised := false
|
||||
for _, mechanism := range server.Auth {
|
||||
if mechanism == "LOGIN" {
|
||||
advertised = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !advertised {
|
||||
return "", nil, errors.New("gomail: unencrypted connection")
|
||||
}
|
||||
}
|
||||
func (a *plainAuth) Start(server *smtp.ServerInfo) (string, []byte, error) {
|
||||
if server.Name != a.host {
|
||||
return "", nil, errors.New("gomail: wrong host name")
|
||||
}
|
||||
|
||||
var plain, login bool
|
||||
for _, a := range server.Auth {
|
||||
switch a {
|
||||
case "PLAIN":
|
||||
plain = true
|
||||
case "LOGIN":
|
||||
login = true
|
||||
}
|
||||
}
|
||||
|
||||
if !server.TLS && !plain && !login {
|
||||
return "", nil, errors.New("gomail: unencrypted connection")
|
||||
}
|
||||
|
||||
if !plain && login {
|
||||
a.login = true
|
||||
return "LOGIN", nil, nil
|
||||
}
|
||||
|
||||
return "PLAIN", []byte("\x00" + a.username + "\x00" + a.password), nil
|
||||
}
|
||||
|
||||
func (a *loginAuth) Next(fromServer []byte, more bool) ([]byte, error) {
|
||||
func (a *plainAuth) Next(fromServer []byte, more bool) ([]byte, error) {
|
||||
if !a.login {
|
||||
if more {
|
||||
return nil, errors.New("gomail: unexpected server challenge")
|
||||
}
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
if !more {
|
||||
return nil, nil
|
||||
}
|
||||
|
|
82
auth_test.go
82
auth_test.go
|
@ -11,51 +11,103 @@ const (
|
|||
testHost = "smtp.example.com"
|
||||
)
|
||||
|
||||
type authTest struct {
|
||||
var testAuth = &plainAuth{
|
||||
username: testUser,
|
||||
password: testPwd,
|
||||
host: testHost,
|
||||
}
|
||||
|
||||
type plainAuthTest struct {
|
||||
auths []string
|
||||
challenges []string
|
||||
tls bool
|
||||
wantProto string
|
||||
wantData []string
|
||||
wantError bool
|
||||
}
|
||||
|
||||
func TestNoAdvertisement(t *testing.T) {
|
||||
testLoginAuth(t, &authTest{
|
||||
testPlainAuth(t, &plainAuthTest{
|
||||
auths: []string{},
|
||||
challenges: []string{"Username:", "Password:"},
|
||||
tls: false,
|
||||
wantProto: "PLAIN",
|
||||
wantError: true,
|
||||
})
|
||||
}
|
||||
|
||||
func TestNoAdvertisementTLS(t *testing.T) {
|
||||
testLoginAuth(t, &authTest{
|
||||
testPlainAuth(t, &plainAuthTest{
|
||||
auths: []string{},
|
||||
challenges: []string{"Username:", "Password:"},
|
||||
tls: true,
|
||||
wantData: []string{"", testUser, testPwd},
|
||||
wantProto: "PLAIN",
|
||||
wantData: []string{"\x00" + testUser + "\x00" + testPwd},
|
||||
})
|
||||
}
|
||||
|
||||
func TestPlain(t *testing.T) {
|
||||
testPlainAuth(t, &plainAuthTest{
|
||||
auths: []string{"PLAIN"},
|
||||
challenges: []string{"Username:", "Password:"},
|
||||
tls: false,
|
||||
wantProto: "PLAIN",
|
||||
wantData: []string{"\x00" + testUser + "\x00" + testPwd},
|
||||
})
|
||||
}
|
||||
|
||||
func TestPlainTLS(t *testing.T) {
|
||||
testPlainAuth(t, &plainAuthTest{
|
||||
auths: []string{"PLAIN"},
|
||||
challenges: []string{"Username:", "Password:"},
|
||||
tls: true,
|
||||
wantProto: "PLAIN",
|
||||
wantData: []string{"\x00" + testUser + "\x00" + testPwd},
|
||||
})
|
||||
}
|
||||
|
||||
func TestPlainAndLogin(t *testing.T) {
|
||||
testPlainAuth(t, &plainAuthTest{
|
||||
auths: []string{"PLAIN", "LOGIN"},
|
||||
challenges: []string{"Username:", "Password:"},
|
||||
tls: false,
|
||||
wantProto: "PLAIN",
|
||||
wantData: []string{"\x00" + testUser + "\x00" + testPwd},
|
||||
})
|
||||
}
|
||||
|
||||
func TestPlainAndLoginTLS(t *testing.T) {
|
||||
testPlainAuth(t, &plainAuthTest{
|
||||
auths: []string{"PLAIN", "LOGIN"},
|
||||
challenges: []string{"Username:", "Password:"},
|
||||
tls: true,
|
||||
wantProto: "PLAIN",
|
||||
wantData: []string{"\x00" + testUser + "\x00" + testPwd},
|
||||
})
|
||||
}
|
||||
|
||||
func TestLogin(t *testing.T) {
|
||||
testLoginAuth(t, &authTest{
|
||||
auths: []string{"PLAIN", "LOGIN"},
|
||||
testPlainAuth(t, &plainAuthTest{
|
||||
auths: []string{"LOGIN"},
|
||||
challenges: []string{"Username:", "Password:"},
|
||||
tls: false,
|
||||
wantProto: "LOGIN",
|
||||
wantData: []string{"", testUser, testPwd},
|
||||
})
|
||||
}
|
||||
|
||||
func TestLoginTLS(t *testing.T) {
|
||||
testLoginAuth(t, &authTest{
|
||||
testPlainAuth(t, &plainAuthTest{
|
||||
auths: []string{"LOGIN"},
|
||||
challenges: []string{"Username:", "Password:"},
|
||||
tls: true,
|
||||
wantProto: "LOGIN",
|
||||
wantData: []string{"", testUser, testPwd},
|
||||
})
|
||||
}
|
||||
|
||||
func testLoginAuth(t *testing.T, test *authTest) {
|
||||
auth := &loginAuth{
|
||||
func testPlainAuth(t *testing.T, test *plainAuthTest) {
|
||||
auth := &plainAuth{
|
||||
username: testUser,
|
||||
password: testPwd,
|
||||
host: testHost,
|
||||
|
@ -67,13 +119,13 @@ func testLoginAuth(t *testing.T, test *authTest) {
|
|||
}
|
||||
proto, toServer, err := auth.Start(server)
|
||||
if err != nil && !test.wantError {
|
||||
t.Fatalf("loginAuth.Start(): %v", err)
|
||||
t.Fatalf("plainAuth.Start(): %v", err)
|
||||
}
|
||||
if err != nil && test.wantError {
|
||||
return
|
||||
}
|
||||
if proto != "LOGIN" {
|
||||
t.Errorf("invalid protocol, got %q, want LOGIN", proto)
|
||||
if proto != test.wantProto {
|
||||
t.Errorf("invalid protocol, got %q, want %q", proto, test.wantProto)
|
||||
}
|
||||
|
||||
i := 0
|
||||
|
@ -82,6 +134,10 @@ func testLoginAuth(t *testing.T, test *authTest) {
|
|||
t.Errorf("Invalid response, got %q, want %q", got, test.wantData[i])
|
||||
}
|
||||
|
||||
if proto == "PLAIN" {
|
||||
return
|
||||
}
|
||||
|
||||
for _, challenge := range test.challenges {
|
||||
i++
|
||||
if i >= len(test.wantData) {
|
||||
|
@ -90,7 +146,7 @@ func testLoginAuth(t *testing.T, test *authTest) {
|
|||
|
||||
toServer, err = auth.Next([]byte(challenge), true)
|
||||
if err != nil {
|
||||
t.Fatalf("loginAuth.Auth(): %v", err)
|
||||
t.Fatalf("plainAuth.Auth(): %v", err)
|
||||
}
|
||||
got = string(toServer)
|
||||
if got != test.wantData[i] {
|
||||
|
|
|
@ -5,6 +5,7 @@ import (
|
|||
"html/template"
|
||||
"io"
|
||||
"log"
|
||||
"net/smtp"
|
||||
"time"
|
||||
|
||||
"gopkg.in/gomail.v2"
|
||||
|
@ -19,7 +20,7 @@ func Example() {
|
|||
m.SetBody("text/html", "Hello <b>Bob</b> and <i>Cora</i>!")
|
||||
m.Attach("/home/Alex/lolcat.jpg")
|
||||
|
||||
d := gomail.NewDialer("smtp.example.com", 587, "user", "123456")
|
||||
d := gomail.NewPlainDialer("smtp.example.com", 587, "user", "123456")
|
||||
|
||||
// Send the email to Bob, Cora and Dan.
|
||||
if err := d.DialAndSend(m); err != nil {
|
||||
|
@ -32,7 +33,7 @@ func Example_daemon() {
|
|||
ch := make(chan *gomail.Message)
|
||||
|
||||
go func() {
|
||||
d := gomail.NewDialer("smtp.example.com", 587, "user", "123456")
|
||||
d := gomail.NewPlainDialer("smtp.example.com", 587, "user", "123456")
|
||||
|
||||
var s gomail.SendCloser
|
||||
var err error
|
||||
|
@ -79,7 +80,7 @@ func Example_newsletter() {
|
|||
Address string
|
||||
}
|
||||
|
||||
d := gomail.NewDialer("smtp.example.com", 587, "user", "123456")
|
||||
d := gomail.NewPlainDialer("smtp.example.com", 587, "user", "123456")
|
||||
s, err := d.Dial()
|
||||
if err != nil {
|
||||
panic(err)
|
||||
|
@ -113,6 +114,24 @@ func Example_noAuth() {
|
|||
}
|
||||
}
|
||||
|
||||
// Send an email using the CRAM-MD5 authentication mechanism.
|
||||
func Example_cRAMMD5() {
|
||||
m := gomail.NewMessage()
|
||||
m.SetHeader("From", "from@example.com")
|
||||
m.SetHeader("To", "to@example.com")
|
||||
m.SetHeader("Subject", "Hello!")
|
||||
m.SetBody("text/plain", "Hello!")
|
||||
|
||||
d := gomail.Dialer{
|
||||
Host: "localhost",
|
||||
Port: 587,
|
||||
Auth: smtp.CRAMMD5Auth("username", "secret"),
|
||||
}
|
||||
if err := d.DialAndSend(m); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
// Send an email using an API or postfix.
|
||||
func Example_noSMTP() {
|
||||
m := gomail.NewMessage()
|
||||
|
@ -151,10 +170,6 @@ func ExampleSetHeader() {
|
|||
m.Attach("foo.jpg", gomail.SetHeader(h))
|
||||
}
|
||||
|
||||
func ExampleRename() {
|
||||
m.Attach("/tmp/0000146.jpg", gomail.Rename("picture.jpg"))
|
||||
}
|
||||
|
||||
func ExampleMessage_AddAlternative() {
|
||||
m.SetBody("text/plain", "Hello!")
|
||||
m.AddAlternative("text/html", "<p>Hello!</p>")
|
||||
|
|
12
message.go
12
message.go
|
@ -127,10 +127,6 @@ func (m *Message) SetAddressHeader(field, address, name string) {
|
|||
|
||||
// FormatAddress formats an address and a name as a valid RFC 5322 address.
|
||||
func (m *Message) FormatAddress(address, name string) string {
|
||||
if name == "" {
|
||||
return address
|
||||
}
|
||||
|
||||
enc := m.encodeString(name)
|
||||
if enc == name {
|
||||
m.buf.WriteByte('"')
|
||||
|
@ -264,14 +260,6 @@ func SetHeader(h map[string][]string) FileSetting {
|
|||
}
|
||||
}
|
||||
|
||||
// Rename is a file setting to set the name of the attachment if the name is
|
||||
// different than the filename on disk.
|
||||
func Rename(name string) FileSetting {
|
||||
return func(f *file) {
|
||||
f.Name = name
|
||||
}
|
||||
}
|
||||
|
||||
// SetCopyFunc is a file setting to replace the function that runs when the
|
||||
// message is sent. It should copy the content of the file to the io.Writer.
|
||||
//
|
||||
|
|
|
@ -150,8 +150,7 @@ func TestAlternative(t *testing.T) {
|
|||
to: []string{"to@example.com"},
|
||||
content: "From: from@example.com\r\n" +
|
||||
"To: to@example.com\r\n" +
|
||||
"Content-Type: multipart/alternative;\r\n" +
|
||||
" boundary=_BOUNDARY_1_\r\n" +
|
||||
"Content-Type: multipart/alternative; boundary=_BOUNDARY_1_\r\n" +
|
||||
"\r\n" +
|
||||
"--_BOUNDARY_1_\r\n" +
|
||||
"Content-Type: text/plain; charset=UTF-8\r\n" +
|
||||
|
@ -181,8 +180,7 @@ func TestPartSetting(t *testing.T) {
|
|||
to: []string{"to@example.com"},
|
||||
content: "From: from@example.com\r\n" +
|
||||
"To: to@example.com\r\n" +
|
||||
"Content-Type: multipart/alternative;\r\n" +
|
||||
" boundary=_BOUNDARY_1_\r\n" +
|
||||
"Content-Type: multipart/alternative; boundary=_BOUNDARY_1_\r\n" +
|
||||
"\r\n" +
|
||||
"--_BOUNDARY_1_\r\n" +
|
||||
"Content-Type: text/plain; format=flowed; charset=UTF-8\r\n" +
|
||||
|
@ -218,8 +216,7 @@ func TestBodyWriter(t *testing.T) {
|
|||
to: []string{"to@example.com"},
|
||||
content: "From: from@example.com\r\n" +
|
||||
"To: to@example.com\r\n" +
|
||||
"Content-Type: multipart/alternative;\r\n" +
|
||||
" boundary=_BOUNDARY_1_\r\n" +
|
||||
"Content-Type: multipart/alternative; boundary=_BOUNDARY_1_\r\n" +
|
||||
"\r\n" +
|
||||
"--_BOUNDARY_1_\r\n" +
|
||||
"Content-Type: text/plain; charset=UTF-8\r\n" +
|
||||
|
@ -270,8 +267,7 @@ func TestAttachment(t *testing.T) {
|
|||
to: []string{"to@example.com"},
|
||||
content: "From: from@example.com\r\n" +
|
||||
"To: to@example.com\r\n" +
|
||||
"Content-Type: multipart/mixed;\r\n" +
|
||||
" boundary=_BOUNDARY_1_\r\n" +
|
||||
"Content-Type: multipart/mixed; boundary=_BOUNDARY_1_\r\n" +
|
||||
"\r\n" +
|
||||
"--_BOUNDARY_1_\r\n" +
|
||||
"Content-Type: text/plain; charset=UTF-8\r\n" +
|
||||
|
@ -290,40 +286,6 @@ func TestAttachment(t *testing.T) {
|
|||
testMessage(t, m, 1, want)
|
||||
}
|
||||
|
||||
func TestRename(t *testing.T) {
|
||||
m := NewMessage()
|
||||
m.SetHeader("From", "from@example.com")
|
||||
m.SetHeader("To", "to@example.com")
|
||||
m.SetBody("text/plain", "Test")
|
||||
name, copy := mockCopyFile("/tmp/test.pdf")
|
||||
rename := Rename("another.pdf")
|
||||
m.Attach(name, copy, rename)
|
||||
|
||||
want := &message{
|
||||
from: "from@example.com",
|
||||
to: []string{"to@example.com"},
|
||||
content: "From: from@example.com\r\n" +
|
||||
"To: to@example.com\r\n" +
|
||||
"Content-Type: multipart/mixed;\r\n" +
|
||||
" boundary=_BOUNDARY_1_\r\n" +
|
||||
"\r\n" +
|
||||
"--_BOUNDARY_1_\r\n" +
|
||||
"Content-Type: text/plain; charset=UTF-8\r\n" +
|
||||
"Content-Transfer-Encoding: quoted-printable\r\n" +
|
||||
"\r\n" +
|
||||
"Test\r\n" +
|
||||
"--_BOUNDARY_1_\r\n" +
|
||||
"Content-Type: application/pdf; name=\"another.pdf\"\r\n" +
|
||||
"Content-Disposition: attachment; filename=\"another.pdf\"\r\n" +
|
||||
"Content-Transfer-Encoding: base64\r\n" +
|
||||
"\r\n" +
|
||||
base64.StdEncoding.EncodeToString([]byte("Content of test.pdf")) + "\r\n" +
|
||||
"--_BOUNDARY_1_--\r\n",
|
||||
}
|
||||
|
||||
testMessage(t, m, 1, want)
|
||||
}
|
||||
|
||||
func TestAttachmentsOnly(t *testing.T) {
|
||||
m := NewMessage()
|
||||
m.SetHeader("From", "from@example.com")
|
||||
|
@ -336,8 +298,7 @@ func TestAttachmentsOnly(t *testing.T) {
|
|||
to: []string{"to@example.com"},
|
||||
content: "From: from@example.com\r\n" +
|
||||
"To: to@example.com\r\n" +
|
||||
"Content-Type: multipart/mixed;\r\n" +
|
||||
" boundary=_BOUNDARY_1_\r\n" +
|
||||
"Content-Type: multipart/mixed; boundary=_BOUNDARY_1_\r\n" +
|
||||
"\r\n" +
|
||||
"--_BOUNDARY_1_\r\n" +
|
||||
"Content-Type: application/pdf; name=\"test.pdf\"\r\n" +
|
||||
|
@ -370,8 +331,7 @@ func TestAttachments(t *testing.T) {
|
|||
to: []string{"to@example.com"},
|
||||
content: "From: from@example.com\r\n" +
|
||||
"To: to@example.com\r\n" +
|
||||
"Content-Type: multipart/mixed;\r\n" +
|
||||
" boundary=_BOUNDARY_1_\r\n" +
|
||||
"Content-Type: multipart/mixed; boundary=_BOUNDARY_1_\r\n" +
|
||||
"\r\n" +
|
||||
"--_BOUNDARY_1_\r\n" +
|
||||
"Content-Type: text/plain; charset=UTF-8\r\n" +
|
||||
|
@ -409,8 +369,7 @@ func TestEmbedded(t *testing.T) {
|
|||
to: []string{"to@example.com"},
|
||||
content: "From: from@example.com\r\n" +
|
||||
"To: to@example.com\r\n" +
|
||||
"Content-Type: multipart/related;\r\n" +
|
||||
" boundary=_BOUNDARY_1_\r\n" +
|
||||
"Content-Type: multipart/related; boundary=_BOUNDARY_1_\r\n" +
|
||||
"\r\n" +
|
||||
"--_BOUNDARY_1_\r\n" +
|
||||
"Content-Type: text/plain; charset=UTF-8\r\n" +
|
||||
|
@ -451,16 +410,13 @@ func TestFullMessage(t *testing.T) {
|
|||
to: []string{"to@example.com"},
|
||||
content: "From: from@example.com\r\n" +
|
||||
"To: to@example.com\r\n" +
|
||||
"Content-Type: multipart/mixed;\r\n" +
|
||||
" boundary=_BOUNDARY_1_\r\n" +
|
||||
"Content-Type: multipart/mixed; boundary=_BOUNDARY_1_\r\n" +
|
||||
"\r\n" +
|
||||
"--_BOUNDARY_1_\r\n" +
|
||||
"Content-Type: multipart/related;\r\n" +
|
||||
" boundary=_BOUNDARY_2_\r\n" +
|
||||
"Content-Type: multipart/related; boundary=_BOUNDARY_2_\r\n" +
|
||||
"\r\n" +
|
||||
"--_BOUNDARY_2_\r\n" +
|
||||
"Content-Type: multipart/alternative;\r\n" +
|
||||
" boundary=_BOUNDARY_3_\r\n" +
|
||||
"Content-Type: multipart/alternative; boundary=_BOUNDARY_3_\r\n" +
|
||||
"\r\n" +
|
||||
"--_BOUNDARY_3_\r\n" +
|
||||
"Content-Type: text/plain; charset=UTF-8\r\n" +
|
||||
|
@ -564,18 +520,6 @@ func TestBase64LineLength(t *testing.T) {
|
|||
testMessage(t, m, 0, want)
|
||||
}
|
||||
|
||||
func TestEmptyName(t *testing.T) {
|
||||
m := NewMessage()
|
||||
m.SetAddressHeader("From", "from@example.com", "")
|
||||
|
||||
want := &message{
|
||||
from: "from@example.com",
|
||||
content: "From: from@example.com\r\n",
|
||||
}
|
||||
|
||||
testMessage(t, m, 0, want)
|
||||
}
|
||||
|
||||
func TestEmptyHeader(t *testing.T) {
|
||||
m := NewMessage()
|
||||
m.SetHeaders(map[string][]string{
|
||||
|
@ -586,7 +530,7 @@ func TestEmptyHeader(t *testing.T) {
|
|||
want := &message{
|
||||
from: "from@example.com",
|
||||
content: "From: from@example.com\r\n" +
|
||||
"X-Empty:\r\n",
|
||||
"X-Empty: \r\n",
|
||||
}
|
||||
|
||||
testMessage(t, m, 0, want)
|
||||
|
|
2
mime.go
2
mime.go
|
@ -5,7 +5,6 @@ package gomail
|
|||
import (
|
||||
"mime"
|
||||
"mime/quotedprintable"
|
||||
"strings"
|
||||
)
|
||||
|
||||
var newQPWriter = quotedprintable.NewWriter
|
||||
|
@ -17,5 +16,4 @@ type mimeEncoder struct {
|
|||
var (
|
||||
bEncoding = mimeEncoder{mime.BEncoding}
|
||||
qEncoding = mimeEncoder{mime.QEncoding}
|
||||
lastIndexByte = strings.LastIndexByte
|
||||
)
|
||||
|
|
|
@ -13,13 +13,4 @@ type mimeEncoder struct {
|
|||
var (
|
||||
bEncoding = mimeEncoder{quotedprintable.BEncoding}
|
||||
qEncoding = mimeEncoder{quotedprintable.QEncoding}
|
||||
lastIndexByte = func(s string, c byte) int {
|
||||
for i := len(s) - 1; i >= 0; i-- {
|
||||
|
||||
if s[i] == c {
|
||||
return i
|
||||
}
|
||||
}
|
||||
return -1
|
||||
}
|
||||
)
|
||||
|
|
11
send.go
11
send.go
|
@ -20,7 +20,7 @@ type SendCloser interface {
|
|||
Close() error
|
||||
}
|
||||
|
||||
// A SendFunc is a function that sends emails to the given addresses.
|
||||
// A SendFunc is a function that sends emails to the given adresses.
|
||||
//
|
||||
// The SendFunc type is an adapter to allow the use of ordinary functions as
|
||||
// email senders. If f is a function with the appropriate signature, SendFunc(f)
|
||||
|
@ -108,9 +108,10 @@ func addAddress(list []string, addr string) []string {
|
|||
}
|
||||
|
||||
func parseAddress(field string) (string, error) {
|
||||
addr, err := mail.ParseAddress(field)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("gomail: invalid address %q: %v", field, err)
|
||||
a, err := mail.ParseAddress(field)
|
||||
if a == nil {
|
||||
return "", err
|
||||
}
|
||||
return addr.Address, nil
|
||||
|
||||
return a.Address, err
|
||||
}
|
||||
|
|
108
smtp.go
108
smtp.go
|
@ -6,8 +6,6 @@ import (
|
|||
"io"
|
||||
"net"
|
||||
"net/smtp"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// A Dialer is a dialer to an SMTP server.
|
||||
|
@ -16,10 +14,6 @@ type Dialer struct {
|
|||
Host string
|
||||
// Port represents the port of the SMTP server.
|
||||
Port int
|
||||
// Username is the username to use to authenticate to the SMTP server.
|
||||
Username string
|
||||
// Password is the password to use to authenticate to the SMTP server.
|
||||
Password string
|
||||
// Auth represents the authentication mechanism used to authenticate to the
|
||||
// SMTP server.
|
||||
Auth smtp.Auth
|
||||
|
@ -35,39 +29,53 @@ type Dialer struct {
|
|||
LocalName string
|
||||
}
|
||||
|
||||
// NewDialer returns a new SMTP Dialer. The given parameters are used to connect
|
||||
// to the SMTP server.
|
||||
func NewDialer(host string, port int, username, password string) *Dialer {
|
||||
// NewPlainDialer returns a Dialer. The given parameters are used to connect to
|
||||
// the SMTP server via a PLAIN authentication mechanism.
|
||||
//
|
||||
// It fallbacks to the LOGIN mechanism if it is the only mechanism advertised by
|
||||
// the server.
|
||||
func NewPlainDialer(host string, port int, username, password string) *Dialer {
|
||||
return &Dialer{
|
||||
Host: host,
|
||||
Port: port,
|
||||
Username: username,
|
||||
Password: password,
|
||||
Auth: &plainAuth{
|
||||
username: username,
|
||||
password: password,
|
||||
host: host,
|
||||
},
|
||||
SSL: port == 465,
|
||||
}
|
||||
}
|
||||
|
||||
// NewPlainDialer returns a new SMTP Dialer. The given parameters are used to
|
||||
// connect to the SMTP server.
|
||||
//
|
||||
// Deprecated: Use NewDialer instead.
|
||||
func NewPlainDialer(host string, port int, username, password string) *Dialer {
|
||||
return NewDialer(host, port, username, password)
|
||||
}
|
||||
|
||||
// Dial dials and authenticates to an SMTP server. The returned SendCloser
|
||||
// should be closed when done using it.
|
||||
func (d *Dialer) Dial() (SendCloser, error) {
|
||||
conn, err := netDialTimeout("tcp", addr(d.Host, d.Port), 10*time.Second)
|
||||
c, err := d.dial()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if d.SSL {
|
||||
conn = tlsClient(conn, d.tlsConfig())
|
||||
if d.Auth != nil {
|
||||
if ok, _ := c.Extension("AUTH"); ok {
|
||||
if err = c.Auth(d.Auth); err != nil {
|
||||
c.Close()
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
c, err := smtpNewClient(conn, d.Host)
|
||||
return &smtpSender{c}, nil
|
||||
}
|
||||
|
||||
func (d *Dialer) dial() (smtpClient, error) {
|
||||
if d.SSL {
|
||||
return d.sslDial()
|
||||
}
|
||||
return d.starttlsDial()
|
||||
}
|
||||
|
||||
func (d *Dialer) starttlsDial() (smtpClient, error) {
|
||||
c, err := smtpDial(addr(d.Host, d.Port))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
@ -78,46 +86,41 @@ func (d *Dialer) Dial() (SendCloser, error) {
|
|||
}
|
||||
}
|
||||
|
||||
if !d.SSL {
|
||||
if ok, _ := c.Extension("STARTTLS"); ok {
|
||||
if err := c.StartTLS(d.tlsConfig()); err != nil {
|
||||
c.Close()
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
return c, nil
|
||||
}
|
||||
|
||||
func (d *Dialer) sslDial() (smtpClient, error) {
|
||||
conn, err := tlsDial("tcp", addr(d.Host, d.Port), d.tlsConfig())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if d.Auth == nil && d.Username != "" {
|
||||
if ok, auths := c.Extension("AUTH"); ok {
|
||||
if strings.Contains(auths, "CRAM-MD5") {
|
||||
d.Auth = smtp.CRAMMD5Auth(d.Username, d.Password)
|
||||
} else if strings.Contains(auths, "LOGIN") &&
|
||||
!strings.Contains(auths, "PLAIN") {
|
||||
d.Auth = &loginAuth{
|
||||
username: d.Username,
|
||||
password: d.Password,
|
||||
host: d.Host,
|
||||
}
|
||||
} else {
|
||||
d.Auth = smtp.PlainAuth("", d.Username, d.Password, d.Host)
|
||||
}
|
||||
}
|
||||
c, err := newClient(conn, d.Host)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if d.Auth != nil {
|
||||
if err = c.Auth(d.Auth); err != nil {
|
||||
c.Close()
|
||||
if d.LocalName != "" {
|
||||
if err := c.Hello(d.LocalName); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
return &smtpSender{c, d}, nil
|
||||
return c, nil
|
||||
}
|
||||
|
||||
func (d *Dialer) tlsConfig() *tls.Config {
|
||||
if d.TLSConfig == nil {
|
||||
return &tls.Config{ServerName: d.Host}
|
||||
}
|
||||
|
||||
return d.TLSConfig
|
||||
}
|
||||
|
||||
|
@ -139,21 +142,10 @@ func (d *Dialer) DialAndSend(m ...*Message) error {
|
|||
|
||||
type smtpSender struct {
|
||||
smtpClient
|
||||
d *Dialer
|
||||
}
|
||||
|
||||
func (c *smtpSender) Send(from string, to []string, msg io.WriterTo) error {
|
||||
if err := c.Mail(from); err != nil {
|
||||
if err == io.EOF {
|
||||
// This is probably due to a timeout, so reconnect and try again.
|
||||
sc, derr := c.d.Dial()
|
||||
if derr == nil {
|
||||
if s, ok := sc.(*smtpSender); ok {
|
||||
*c = *s
|
||||
return c.Send(from, to, msg)
|
||||
}
|
||||
}
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
|
@ -182,9 +174,11 @@ func (c *smtpSender) Close() error {
|
|||
|
||||
// Stubbed out for tests.
|
||||
var (
|
||||
netDialTimeout = net.DialTimeout
|
||||
tlsClient = tls.Client
|
||||
smtpNewClient = func(conn net.Conn, host string) (smtpClient, error) {
|
||||
smtpDial = func(addr string) (smtpClient, error) {
|
||||
return smtp.Dial(addr)
|
||||
}
|
||||
tlsDial = tls.Dial
|
||||
newClient = func(conn net.Conn, host string) (smtpClient, error) {
|
||||
return smtp.NewClient(conn, host)
|
||||
}
|
||||
)
|
||||
|
|
91
smtp_test.go
91
smtp_test.go
|
@ -8,7 +8,6 @@ import (
|
|||
"net/smtp"
|
||||
"reflect"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
const (
|
||||
|
@ -17,14 +16,12 @@ const (
|
|||
)
|
||||
|
||||
var (
|
||||
testConn = &net.TCPConn{}
|
||||
testTLSConn = &tls.Conn{}
|
||||
testConfig = &tls.Config{InsecureSkipVerify: true}
|
||||
testAuth = smtp.PlainAuth("", testUser, testPwd, testHost)
|
||||
)
|
||||
|
||||
func TestDialer(t *testing.T) {
|
||||
d := NewDialer(testHost, testPort, "user", "pwd")
|
||||
d := NewPlainDialer(testHost, testPort, "user", "pwd")
|
||||
testSendMail(t, d, []string{
|
||||
"Extension STARTTLS",
|
||||
"StartTLS",
|
||||
|
@ -42,7 +39,7 @@ func TestDialer(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestDialerSSL(t *testing.T) {
|
||||
d := NewDialer(testHost, testSSLPort, "user", "pwd")
|
||||
d := NewPlainDialer(testHost, testSSLPort, "user", "pwd")
|
||||
testSendMail(t, d, []string{
|
||||
"Extension AUTH",
|
||||
"Auth",
|
||||
|
@ -58,7 +55,7 @@ func TestDialerSSL(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestDialerConfig(t *testing.T) {
|
||||
d := NewDialer(testHost, testPort, "user", "pwd")
|
||||
d := NewPlainDialer(testHost, testPort, "user", "pwd")
|
||||
d.LocalName = "test"
|
||||
d.TLSConfig = testConfig
|
||||
testSendMail(t, d, []string{
|
||||
|
@ -79,7 +76,7 @@ func TestDialerConfig(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestDialerSSLConfig(t *testing.T) {
|
||||
d := NewDialer(testHost, testSSLPort, "user", "pwd")
|
||||
d := NewPlainDialer(testHost, testSSLPort, "user", "pwd")
|
||||
d.LocalName = "test"
|
||||
d.TLSConfig = testConfig
|
||||
testSendMail(t, d, []string{
|
||||
|
@ -116,35 +113,13 @@ func TestDialerNoAuth(t *testing.T) {
|
|||
})
|
||||
}
|
||||
|
||||
func TestDialerTimeout(t *testing.T) {
|
||||
d := &Dialer{
|
||||
Host: testHost,
|
||||
Port: testPort,
|
||||
}
|
||||
testSendMailTimeout(t, d, []string{
|
||||
"Extension STARTTLS",
|
||||
"StartTLS",
|
||||
"Mail " + testFrom,
|
||||
"Extension STARTTLS",
|
||||
"StartTLS",
|
||||
"Mail " + testFrom,
|
||||
"Rcpt " + testTo1,
|
||||
"Rcpt " + testTo2,
|
||||
"Data",
|
||||
"Write message",
|
||||
"Close writer",
|
||||
"Quit",
|
||||
"Close",
|
||||
})
|
||||
}
|
||||
|
||||
type mockClient struct {
|
||||
t *testing.T
|
||||
i int
|
||||
want []string
|
||||
addr string
|
||||
auth smtp.Auth
|
||||
config *tls.Config
|
||||
timeout bool
|
||||
}
|
||||
|
||||
func (c *mockClient) Hello(localName string) error {
|
||||
|
@ -164,19 +139,13 @@ func (c *mockClient) StartTLS(config *tls.Config) error {
|
|||
}
|
||||
|
||||
func (c *mockClient) Auth(a smtp.Auth) error {
|
||||
if !reflect.DeepEqual(a, testAuth) {
|
||||
c.t.Errorf("Invalid auth, got %#v, want %#v", a, testAuth)
|
||||
}
|
||||
assertAuth(c.t, a, c.auth)
|
||||
c.do("Auth")
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c *mockClient) Mail(from string) error {
|
||||
c.do("Mail " + from)
|
||||
if c.timeout {
|
||||
c.timeout = false
|
||||
return io.EOF
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
|
@ -232,42 +201,32 @@ func (w *mockWriter) Close() error {
|
|||
}
|
||||
|
||||
func testSendMail(t *testing.T, d *Dialer, want []string) {
|
||||
doTestSendMail(t, d, want, false)
|
||||
}
|
||||
|
||||
func testSendMailTimeout(t *testing.T, d *Dialer, want []string) {
|
||||
doTestSendMail(t, d, want, true)
|
||||
}
|
||||
|
||||
func doTestSendMail(t *testing.T, d *Dialer, want []string, timeout bool) {
|
||||
testClient := &mockClient{
|
||||
t: t,
|
||||
want: want,
|
||||
addr: addr(d.Host, d.Port),
|
||||
auth: testAuth,
|
||||
config: d.TLSConfig,
|
||||
timeout: timeout,
|
||||
}
|
||||
|
||||
netDialTimeout = func(network, address string, d time.Duration) (net.Conn, error) {
|
||||
smtpDial = func(addr string) (smtpClient, error) {
|
||||
assertAddr(t, addr, testClient.addr)
|
||||
return testClient, nil
|
||||
}
|
||||
|
||||
tlsDial = func(network, addr string, config *tls.Config) (*tls.Conn, error) {
|
||||
if network != "tcp" {
|
||||
t.Errorf("Invalid network, got %q, want tcp", network)
|
||||
}
|
||||
if address != testClient.addr {
|
||||
t.Errorf("Invalid address, got %q, want %q",
|
||||
address, testClient.addr)
|
||||
}
|
||||
return testConn, nil
|
||||
}
|
||||
|
||||
tlsClient = func(conn net.Conn, config *tls.Config) *tls.Conn {
|
||||
if conn != testConn {
|
||||
t.Errorf("Invalid conn, got %#v, want %#v", conn, testConn)
|
||||
}
|
||||
assertAddr(t, addr, testClient.addr)
|
||||
assertConfig(t, config, testClient.config)
|
||||
return testTLSConn
|
||||
return testTLSConn, nil
|
||||
}
|
||||
|
||||
smtpNewClient = func(conn net.Conn, host string) (smtpClient, error) {
|
||||
newClient = func(conn net.Conn, host string) (smtpClient, error) {
|
||||
if conn != testTLSConn {
|
||||
t.Error("Invalid TLS connection used")
|
||||
}
|
||||
if host != testHost {
|
||||
t.Errorf("Invalid host, got %q, want %q", host, testHost)
|
||||
}
|
||||
|
@ -279,6 +238,18 @@ func doTestSendMail(t *testing.T, d *Dialer, want []string, timeout bool) {
|
|||
}
|
||||
}
|
||||
|
||||
func assertAuth(t *testing.T, got, want smtp.Auth) {
|
||||
if !reflect.DeepEqual(got, want) {
|
||||
t.Errorf("Invalid auth, got %#v, want %#v", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func assertAddr(t *testing.T, got, want string) {
|
||||
if got != want {
|
||||
t.Errorf("Invalid addr, got %q, want %q", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
func assertConfig(t *testing.T, got, want *tls.Config) {
|
||||
if want == nil {
|
||||
want = &tls.Config{ServerName: testHost}
|
||||
|
|
72
writeto.go
72
writeto.go
|
@ -7,7 +7,6 @@ import (
|
|||
"mime"
|
||||
"mime/multipart"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
|
@ -79,7 +78,7 @@ type messageWriter struct {
|
|||
|
||||
func (w *messageWriter) openMultipart(mimeType string) {
|
||||
mw := multipart.NewWriter(w)
|
||||
contentType := "multipart/" + mimeType + ";\r\n boundary=" + mw.Boundary()
|
||||
contentType := "multipart/" + mimeType + "; boundary=" + mw.Boundary()
|
||||
w.writers[w.depth] = mw
|
||||
|
||||
if w.depth == 0 {
|
||||
|
@ -164,80 +163,17 @@ func (w *messageWriter) writeString(s string) {
|
|||
|
||||
func (w *messageWriter) writeHeader(k string, v ...string) {
|
||||
w.writeString(k)
|
||||
if len(v) == 0 {
|
||||
w.writeString(":\r\n")
|
||||
return
|
||||
}
|
||||
w.writeString(": ")
|
||||
|
||||
// Max header line length is 78 characters in RFC 5322 and 76 characters
|
||||
// in RFC 2047. So for the sake of simplicity we use the 76 characters
|
||||
// limit.
|
||||
charsLeft := 76 - len(k) - len(": ")
|
||||
|
||||
for i, s := range v {
|
||||
// If the line is already too long, insert a newline right away.
|
||||
if charsLeft < 1 {
|
||||
if i == 0 {
|
||||
w.writeString("\r\n ")
|
||||
} else {
|
||||
w.writeString(",\r\n ")
|
||||
}
|
||||
charsLeft = 75
|
||||
} else if i != 0 {
|
||||
if len(v) > 0 {
|
||||
w.writeString(v[0])
|
||||
for _, s := range v[1:] {
|
||||
w.writeString(", ")
|
||||
charsLeft -= 2
|
||||
}
|
||||
|
||||
// While the header content is too long, fold it by inserting a newline.
|
||||
for len(s) > charsLeft {
|
||||
s = w.writeLine(s, charsLeft)
|
||||
charsLeft = 75
|
||||
}
|
||||
w.writeString(s)
|
||||
if i := lastIndexByte(s, '\n'); i != -1 {
|
||||
charsLeft = 75 - (len(s) - i - 1)
|
||||
} else {
|
||||
charsLeft -= len(s)
|
||||
}
|
||||
}
|
||||
w.writeString("\r\n")
|
||||
}
|
||||
|
||||
func (w *messageWriter) writeLine(s string, charsLeft int) string {
|
||||
// If there is already a newline before the limit. Write the line.
|
||||
if i := strings.IndexByte(s, '\n'); i != -1 && i < charsLeft {
|
||||
w.writeString(s[:i+1])
|
||||
return s[i+1:]
|
||||
}
|
||||
|
||||
for i := charsLeft - 1; i >= 0; i-- {
|
||||
if s[i] == ' ' {
|
||||
w.writeString(s[:i])
|
||||
w.writeString("\r\n ")
|
||||
return s[i+1:]
|
||||
}
|
||||
}
|
||||
|
||||
// We could not insert a newline cleanly so look for a space or a newline
|
||||
// even if it is after the limit.
|
||||
for i := 75; i < len(s); i++ {
|
||||
if s[i] == ' ' {
|
||||
w.writeString(s[:i])
|
||||
w.writeString("\r\n ")
|
||||
return s[i+1:]
|
||||
}
|
||||
if s[i] == '\n' {
|
||||
w.writeString(s[:i+1])
|
||||
return s[i+1:]
|
||||
}
|
||||
}
|
||||
|
||||
// Too bad, no space or newline in the whole string. Just write everything.
|
||||
w.writeString(s)
|
||||
return ""
|
||||
}
|
||||
|
||||
func (w *messageWriter) writeHeaders(h map[string][]string) {
|
||||
if w.depth == 0 {
|
||||
for k, v := range h {
|
||||
|
|
Loading…
Reference in New Issue