README.md

@@ -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.

auth.go

@@ -7,33 +7,51 @@ import (
 	"net/smtp"
 )
 
-// loginAuth is an smtp.Auth that implements the LOGIN authentication mechanism.
+// plainAuth is an smtp.Auth that implements the PLAIN authentication mechanism.
-type loginAuth struct {
+// 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) {
+func (a *plainAuth) Start(server *smtp.ServerInfo) (string, []byte, error) {
-	if !server.TLS {
-		advertised := false
-		for _, mechanism := range server.Auth {
-			if mechanism == "LOGIN" {
-				advertised = true
-				break
-			}
-		}
-		if !advertised {
-			return "", nil, errors.New("gomail: unencrypted connection")
-		}
-	}
 	if server.Name != a.host {
 		return "", nil, errors.New("gomail: wrong host name")
 	}
+
+	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
 	}

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{
+	testPlainAuth(t, &plainAuthTest{
-		auths:      []string{"PLAIN", "LOGIN"},
+		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) {
+func testPlainAuth(t *testing.T, test *plainAuthTest) {
-	auth := &loginAuth{
+	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" {
+	if proto != test.wantProto {
-		t.Errorf("invalid protocol, got %q, want LOGIN", proto)
+		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] {

example_test.go

@@ -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>")

go.mod

@@ -1,3 +0,0 @@
-module git.lovezsh.com/go-kit/gomail
-
-go 1.21.3

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.
 //

message_test.go

@@ -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" +
+			"Content-Type: multipart/alternative; boundary=_BOUNDARY_1_\r\n" +
-			" 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" +
+			"Content-Type: multipart/alternative; boundary=_BOUNDARY_1_\r\n" +
-			" 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" +
+			"Content-Type: multipart/alternative; boundary=_BOUNDARY_1_\r\n" +
-			" 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" +
+			"Content-Type: multipart/mixed; boundary=_BOUNDARY_1_\r\n" +
-			" 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" +
+			"Content-Type: multipart/mixed; boundary=_BOUNDARY_1_\r\n" +
-			" 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" +
+			"Content-Type: multipart/mixed; boundary=_BOUNDARY_1_\r\n" +
-			" 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" +
+			"Content-Type: multipart/related; boundary=_BOUNDARY_1_\r\n" +
-			" 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" +
+			"Content-Type: multipart/mixed; boundary=_BOUNDARY_1_\r\n" +
-			" boundary=_BOUNDARY_1_\r\n" +
 			"\r\n" +
 			"--_BOUNDARY_1_\r\n" +
-			"Content-Type: multipart/related;\r\n" +
+			"Content-Type: multipart/related; boundary=_BOUNDARY_2_\r\n" +
-			" boundary=_BOUNDARY_2_\r\n" +
 			"\r\n" +
 			"--_BOUNDARY_2_\r\n" +
-			"Content-Type: multipart/alternative;\r\n" +
+			"Content-Type: multipart/alternative; boundary=_BOUNDARY_3_\r\n" +
-			" 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)

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
 )

mime_go14.go

@@ -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
-	}
 )

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)
+	a, err := mail.ParseAddress(field)
-	if err != nil {
+	if a == nil {
-		return "", fmt.Errorf("gomail: invalid address %q: %v", field, err)
+		return "", err
 	}
-	return addr.Address, nil
+
+	return a.Address, err
 }

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
+// NewPlainDialer returns a Dialer. The given parameters are used to connect to
-// to the SMTP server.
+// the SMTP server via a PLAIN authentication mechanism.
-func NewDialer(host string, port int, username, password string) *Dialer {
+//
+// 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,
+		Auth: &plainAuth{
-		Password: password,
+			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 {
+	if d.Auth != nil {
-		conn = tlsClient(conn, d.tlsConfig())
+		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 != "" {
+	c, err := newClient(conn, d.Host)
-		if ok, auths := c.Extension("AUTH"); ok {
+	if err != nil {
-			if strings.Contains(auths, "CRAM-MD5") {
+		return nil, err
-				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)
-			}
-		}
 	}
 
-	if d.Auth != nil {
+	if d.LocalName != "" {
-		if err = c.Auth(d.Auth); err != nil {
+		if err := c.Hello(d.LocalName); err != nil {
-			c.Close()
 			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
+	smtpDial = func(addr string) (smtpClient, error) {
-	tlsClient      = tls.Client
+		return smtp.Dial(addr)
-	smtpNewClient  = func(conn net.Conn, host string) (smtpClient, error) {
+	}
+	tlsDial   = tls.Dial
+	newClient = func(conn net.Conn, host string) (smtpClient, error) {
 		return smtp.NewClient(conn, host)
 	}
 )

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) {
+	assertAuth(c.t, a, c.auth)
-		c.t.Errorf("Invalid auth, got %#v, want %#v", a, testAuth)
-	}
 	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 {
+		assertAddr(t, addr, 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)
-		}
 		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}

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(": ")
-
+	if len(v) > 0 {
-	// Max header line length is 78 characters in RFC 5322 and 76 characters
+		w.writeString(v[0])
-	// in RFC 2047. So for the sake of simplicity we use the 76 characters
+		for _, s := range v[1:] {
-	// 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 {
 			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 {