feat(smtp): add support for custom client host (#271)

Author: piksel

internal/failures/failure.go

@@ -8,7 +8,7 @@ type FailureID int
 type failure struct {
 	message string
 	id      FailureID
-	stack   string
+	wrapped error
 }
 
 // Failure is an extended error that also includes an ID to be used to identify a specific error
@@ -18,19 +18,27 @@ type Failure interface {
 }
 
 func (f *failure) Error() string {
-	return fmt.Sprintf("%s: %s", f.message, f.stack)
+	if f.wrapped == nil {
+		return f.message
+	}
+	return fmt.Sprintf("%s: %v", f.message, f.wrapped)
+}
+
+func (f *failure) Unwrap() error {
+	return f.wrapped
 }
 
 func (f *failure) ID() FailureID {
 	return f.id
 }
 
+func (f *failure) Is(target error) bool {
+	targetFailure, targetIsFailure := target.(*failure)
+	return targetIsFailure && targetFailure.id == f.id
+}
+
 // Wrap returns a failure with the given message and id, saving the message of wrappedError for appending to Error()
 func Wrap(message string, id FailureID, wrappedError error, v ...interface{}) Failure {
-	var stack string
-	if wrappedError != nil {
-		stack = wrappedError.Error()
-	}
 
 	if len(v) > 0 {
 		message = fmt.Sprintf(message, v...)
@@ -39,7 +47,7 @@ func Wrap(message string, id FailureID, wrappedError error, v ...interface{}) Fa
 	return &failure{
 		message: message,
 		id:      id,
-		stack:   stack,
+		wrapped: wrappedError,
 	}
 }
 

internal/testutils/textconfaker.go

@@ -41,6 +41,11 @@ func (tcf *textConFaker) GetConversation(includeGreeting bool) string {
 		if len(tcf.responses) > ri && !inSequence {
 			resp = tcf.responses[ri]
 		}
+
+		if query == "" && resp == "" && i == len(input)-1 {
+			break
+		}
+
 		conv += fmt.Sprintf("  #%2d >> %50s << %-50s\n", i, query, resp)
 		for len(resp) > 3 && resp[3] == '-' {
 			ri++

pkg/services/smtp/smtp.go

@@ -3,14 +3,15 @@ package smtp
 import (
 	"crypto/tls"
 	"fmt"
-	"github.com/containrrr/shoutrrr/pkg/format"
 	"io"
 	"math/rand"
 	"net"
 	"net/smtp"
 	"net/url"
+	"os"
 	"time"
 
+	"github.com/containrrr/shoutrrr/pkg/format"
 	"github.com/containrrr/shoutrrr/pkg/services/standard"
 	"github.com/containrrr/shoutrrr/pkg/types"
 )
@@ -64,16 +65,16 @@ func (service *Service) Initialize(configURL *url.URL, logger types.StdLogger) e
 
 // Send a notification message to e-mail recipients
 func (service *Service) Send(message string, params *types.Params) error {
-	client, err := getClientConnection(service.config)
-	if err != nil {
-		return fail(FailGetSMTPClient, err)
-	}
-
 	config := service.config.Clone()
 	if err := service.propKeyResolver.UpdateConfigFromParams(&config, params); err != nil {
 		return fail(FailApplySendParams, err)
 	}
 
+	client, err := getClientConnection(service.config)
+	if err != nil {
+		return fail(FailGetSMTPClient, err)
+	}
+
 	return service.doSend(client, message, &config)
 }
 
@@ -106,6 +107,12 @@ func getClientConnection(config *Config) (*smtp.Client, error) {
 
 func (service *Service) doSend(client *smtp.Client, message string, config *Config) failure {
 
+	clientHost := service.resolveClientHost(config)
+
+	if err := client.Hello(clientHost); err != nil {
+		return fail(FailHandshake, err)
+	}
+
 	if config.UseHTML {
 		service.multipartBoundary = fmt.Sprintf("%x", rand.Int63())
 	}
@@ -149,6 +156,20 @@ func (service *Service) doSend(client *smtp.Client, message string, config *Conf
 	return nil
 }
 
+func (service *Service) resolveClientHost(config *Config) string {
+	if config.ClientHost != "auto" {
+		return config.ClientHost
+	}
+
+	hostname, err := os.Hostname()
+	if err != nil {
+		service.Logf("Failed to get hostname, falling back to localhost: %v", err)
+		return "localhost"
+	}
+
+	return hostname
+}
+
 func (service *Service) getAuth(config *Config) (smtp.Auth, failure) {
 
 	switch config.Auth {
@@ -183,7 +204,7 @@ func (service *Service) sendToRecipient(client *smtp.Client, toAddress string, c
 	}
 
 	if err := writeHeaders(wc, service.getHeaders(toAddress, config.Subject)); err != nil {
-		return fail(FailWriteHeaders, err)
+		return err
 	}
 
 	var ferr failure
@@ -256,7 +277,7 @@ func (service *Service) writeMessagePart(wc io.WriteCloser, message string, temp
 			return fail(FailMessageTemplate, err)
 		}
 	} else {
-		if _, err := fmt.Fprintf(wc, message); err != nil {
+		if _, err := fmt.Fprint(wc, message); err != nil {
 			return fail(FailMessageRaw, err)
 		}
 	}
@@ -282,13 +303,16 @@ func writeMultipartHeader(wc io.WriteCloser, boundary string, contentType string
 	return nil
 }
 
-func writeHeaders(wc io.WriteCloser, headers map[string]string) error {
+func writeHeaders(wc io.WriteCloser, headers map[string]string) failure {
 	for key, val := range headers {
 		if _, err := fmt.Fprintf(wc, "%s: %s\n", key, val); err != nil {
-			return err
+			return fail(FailWriteHeaders, err)
 		}
 	}
 
 	_, err := fmt.Fprintln(wc)
-	return err
+	if err != nil {
+		return fail(FailWriteHeaders, err)
+	}
+	return nil
 }

pkg/services/smtp/smtp_config.go

@@ -25,6 +25,7 @@ type Config struct {
 	Encryption  encMethod `desc:"Encryption method" default:"Auto" key:"encryption"`
 	UseStartTLS bool      `desc:"Whether to use StartTLS encryption" default:"Yes" key:"usestarttls,starttls"`
 	UseHTML     bool      `desc:"Whether the message being sent is in HTML" default:"No" key:"usehtml"`
+	ClientHost  string    `desc:"The client host name sent to the SMTP server during HELLO phase. If set to \"auto\" it will use the OS hostname" key:"clienthost" default:"localhost"`
 }
 
 // GetURL returns a URL representation of it's current field values

pkg/services/smtp/smtp_failures.go

@@ -43,35 +43,56 @@ const (
 	FailCreateSMTPClient
 	// FailApplySendParams is returned when updating the send config failed
 	FailApplySendParams
+	// FailHandshake is returned when the initial HELLO handshake returned an error
+	FailHandshake
 )
 
 func fail(failureID failures.FailureID, err error, v ...interface{}) failure {
-	messages := map[int]string{
-		int(FailGetSMTPClient):    "error getting SMTP client",
-		int(FailConnectToServer):  "error connecting to server",
-		int(FailCreateSMTPClient): "error creating smtp client",
-		int(FailEnableStartTLS):   "error enabling StartTLS",
-		int(FailAuthenticating):   "error authenticating",
-		int(FailAuthType):         "invalid authorization method '%s'",
-		int(FailSendRecipient):    "error sending message to recipient",
-		int(FailClosingSession):   "error closing session",
-		int(FailPlainHeader):      "error writing plain header",
-		int(FailHTMLHeader):       "error writing HTML header",
-		int(FailMultiEndHeader):   "error writing multipart end header",
-		int(FailMessageTemplate):  "error applying message template",
-		int(FailMessageRaw):       "error writing message",
-		int(FailSetSender):        "error creating new message",
-		int(FailSetRecipient):     "error setting RCPT",
-		int(FailOpenDataStream):   "error creating message stream",
-		int(FailWriteHeaders):     "error writing message headers",
-		int(FailCloseDataStream):  "error closing message stream",
-		int(FailApplySendParams):  "error applying params to send config",
-		int(FailUnknown):          "an unknown error occurred",
-	}
-
-	msg := messages[int(failureID)]
-	if msg == "" {
-		msg = messages[int(FailUnknown)]
+	var msg string
+	switch failureID {
+	case FailGetSMTPClient:
+		msg = "error getting SMTP client"
+	case FailConnectToServer:
+		msg = "error connecting to server"
+	case FailCreateSMTPClient:
+		msg = "error creating smtp client"
+	case FailEnableStartTLS:
+		msg = "error enabling StartTLS"
+	case FailAuthenticating:
+		msg = "error authenticating"
+	case FailAuthType:
+		msg = "invalid authorization method '%s'"
+	case FailSendRecipient:
+		msg = "error sending message to recipient"
+	case FailClosingSession:
+		msg = "error closing session"
+	case FailPlainHeader:
+		msg = "error writing plain header"
+	case FailHTMLHeader:
+		msg = "error writing HTML header"
+	case FailMultiEndHeader:
+		msg = "error writing multipart end header"
+	case FailMessageTemplate:
+		msg = "error applying message template"
+	case FailMessageRaw:
+		msg = "error writing message"
+	case FailSetSender:
+		msg = "error creating new message"
+	case FailSetRecipient:
+		msg = "error setting RCPT"
+	case FailOpenDataStream:
+		msg = "error creating message stream"
+	case FailWriteHeaders:
+		msg = "error writing message headers"
+	case FailCloseDataStream:
+		msg = "error closing message stream"
+	case FailApplySendParams:
+		msg = "error applying params to send config"
+	case FailHandshake:
+		msg = "server did not accept the handshake"
+	// case FailUnknown:
+	default:
+		msg = "an unknown error occurred"
 	}
 
 	return failures.Wrap(msg, failureID, err, v...)