recv & send

Author: wiggin77

.gitignore

@@ -0,0 +1,3 @@
+mailrelay
+test
+vendor

.vscode/launch.json

@@ -0,0 +1,17 @@
+{
+	// Use IntelliSense to learn about possible attributes.
+	// Hover to view descriptions of existing attributes.
+	// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+	"version": "0.2.0",
+	"configurations": [
+		{
+			"name": "Launch",
+			"type": "go",
+			"request": "launch",
+			"mode": "auto",
+			"program": "${fileDirname}",
+			"env": {},
+			"args": []
+		}
+	]
+}

Gopkg.lock

@@ -0,0 +1,34 @@
+# Gopkg.toml example
+#
+# Refer to https://golang.github.io/dep/docs/Gopkg.toml.html
+# for detailed Gopkg.toml documentation.
+#
+# required = ["github.com/user/thing/cmd/thing"]
+# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
+#
+# [[constraint]]
+#   name = "github.com/user/project"
+#   version = "1.0.0"
+#
+# [[constraint]]
+#   name = "github.com/user/project2"
+#   branch = "dev"
+#   source = "github.com/myfork/project2"
+#
+# [[override]]
+#   name = "github.com/x/y"
+#   version = "2.4.0"
+#
+# [prune]
+#   non-go = false
+#   go-tests = true
+#   unused-packages = true
+
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/flashmob/go-guerrilla"
+
+[prune]
+  go-tests = true
+  unused-packages = true

Gopkg.toml

@@ -0,0 +1,123 @@
+package main
+
+import (
+	"bytes"
+	"crypto/tls"
+	"fmt"
+	"io"
+	"net/smtp"
+	"net/textproto"
+
+	"github.com/flashmob/go-guerrilla/mail"
+	"github.com/pkg/errors"
+)
+
+type closeable interface {
+	Close() error
+}
+
+// sendMail sends the contents of the envelope to a SMTP server.
+func sendMail(e *mail.Envelope, config *mailRelayConfig) error {
+	server := fmt.Sprintf("%s:%d", config.Server, config.Port)
+	to := getTo(e)
+
+	var msg bytes.Buffer
+	msg.Write(e.Data.Bytes())
+	msg.WriteString("\r\n")
+
+	fmt.Println("==== Starting email send ====")
+	defer fmt.Println("==== Finished email send ====")
+	var err error
+	var conn *tls.Conn
+	var client *smtp.Client
+	var writer io.WriteCloser
+
+	tlsconfig := &tls.Config{
+		InsecureSkipVerify: true,
+		ServerName:         config.Server,
+	}
+
+	if conn, err = tls.Dial("tcp", server, tlsconfig); err != nil {
+		return errors.Wrap(err, "dial error")
+	}
+
+	if client, err = smtp.NewClient(conn, config.Server); err != nil {
+		close(conn, "conn")
+		return errors.Wrap(err, "newclient error")
+	}
+	shouldCloseClient := true
+	defer func(shouldClose *bool) {
+		if *shouldClose {
+			close(client, "client")
+		}
+	}(&shouldCloseClient)
+
+	auth := smtp.PlainAuth("", config.Username, config.Password, config.Server)
+	if err = client.Auth(auth); err != nil {
+		return errors.Wrap(err, "auth error")
+	}
+
+	if err = client.Mail(e.MailFrom.String()); err != nil {
+		return errors.Wrap(err, "mail error")
+	}
+
+	for _, addy := range to {
+		if err = client.Rcpt(addy); err != nil {
+			return errors.Wrap(err, "rcpt error")
+		}
+	}
+
+	if writer, err = client.Data(); err != nil {
+		return errors.Wrap(err, "data error")
+	}
+	_, err = writer.Write(msg.Bytes())
+	close(writer, "writer")
+	if err != nil {
+		return errors.Wrap(err, "write error")
+	}
+
+	if err = client.Quit(); isQuitError(err) {
+		return errors.Wrap(err, "quit error")
+	}
+	// We only need to close client if some other error prevented us
+	// from getting to `client.Quit`
+	shouldCloseClient = false
+	return nil
+}
+
+func close(c closeable, what string) {
+	err := c.Close()
+	if err != nil {
+		fmt.Printf("!!!!! Error closing %s: %v\n", what, err)
+	}
+}
+
+func isQuitError(err error) bool {
+	if err == nil {
+		return false
+	}
+	e, ok := err.(*textproto.Error)
+	if ok {
+		// SMTP codes 221 or 250 are acceptable here
+		if e.Code == 221 || e.Code == 250 {
+			return false
+		}
+	}
+	return true
+}
+
+// getTo returns the array of email addresses in the envelope.
+func getTo(e *mail.Envelope) []string {
+	var ret []string
+	for _, addy := range e.RcptTo {
+		ret = append(ret, addy.String())
+	}
+	return ret
+}
+
+func display(b []byte) {
+	s := string(b)
+	fmt.Println("################################")
+	fmt.Printf("%s\n", s)
+	fmt.Println("################################")
+}

client.go

@@ -0,0 +1,70 @@
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"os/signal"
+)
+
+type loggerLevels struct {
+	Debug *log.Logger
+	Error *log.Logger
+}
+
+type mailRelayConfig struct {
+	Server   string `json:"server"`
+	Port     int    `json:"port"`
+	Username string `json:"username"`
+	Password string `json:"password"`
+}
+
+// Logger provides application logging.
+var Logger loggerLevels
+
+func main() {
+
+	Logger.Debug = log.New(os.Stdout, "debug: ", log.Ldate|log.Ltime|log.Lshortfile)
+	Logger.Error = log.New(os.Stderr, "error: ", log.Ldate|log.Ltime|log.Lshortfile)
+
+	var configFile string
+	flag.StringVar(&configFile, "config", "/etc/mailrelay.json", "specifies JSON config file")
+	flag.Parse()
+
+	appConfig, err := loadConfig(configFile)
+	if err != nil {
+		Logger.Error.Fatalf("loading config: %v", err)
+	}
+
+	err = Start(appConfig)
+	if err != nil {
+		Logger.Error.Fatalf("starting server: %v", err)
+	}
+
+	// Wait for SIGINT
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt)
+	signal.Notify(c, os.Kill)
+
+	// Block until a signal is received.
+	s := <-c
+	fmt.Println("Got signal:", s)
+	os.Exit(0)
+}
+
+func loadConfig(path string) (*mailRelayConfig, error) {
+	var cfg mailRelayConfig
+	file, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	parser := json.NewDecoder(file)
+	if err := parser.Decode(&cfg); err != nil {
+		return nil, err
+	}
+	return &cfg, nil
+}

main.go

@@ -0,0 +1,71 @@
+package main
+
+import (
+	"fmt"
+
+	guerrilla "github.com/flashmob/go-guerrilla"
+	"github.com/flashmob/go-guerrilla/backends"
+	"github.com/flashmob/go-guerrilla/log"
+	"github.com/flashmob/go-guerrilla/mail"
+)
+
+// Start starts the server.
+func Start(appConfig *mailRelayConfig) (err error) {
+
+	cfg := &guerrilla.AppConfig{LogFile: log.OutputStdout.String(), AllowedHosts: []string{"warpmail.net"}}
+	sc := guerrilla.ServerConfig{
+		ListenInterface: "0.0.0.0:2525",
+		IsEnabled:       true,
+	}
+	cfg.Servers = append(cfg.Servers, sc)
+
+	bcfg := backends.BackendConfig{
+		"save_workers_size":  3,
+		"save_process":       "HeadersParser|Header|Hasher|Debugger|MailRelay",
+		"log_received_mails": true,
+		"primary_mail_host":  "homeoffice.com",
+		"username":           appConfig.Username,
+		"password":           appConfig.Password,
+		"server":             appConfig.Server,
+		"port":               appConfig.Port,
+	}
+	cfg.BackendConfig = bcfg
+
+	d := guerrilla.Daemon{Config: cfg}
+	d.AddProcessor("MailRelay", mailRelayProcessor)
+
+	return d.Start()
+}
+
+// mailRelayProcessor decorator relays emails to another SMTP server.
+var mailRelayProcessor = func() backends.Decorator {
+	config := &mailRelayConfig{}
+	initFunc := backends.InitializeWith(func(backendConfig backends.BackendConfig) error {
+		configType := backends.BaseConfig(&mailRelayConfig{})
+		bcfg, err := backends.Svc.ExtractConfig(backendConfig, configType)
+		if err != nil {
+			return err
+		}
+		config = bcfg.(*mailRelayConfig)
+		return nil
+	})
+	backends.Svc.AddInitializer(initFunc)
+
+	return func(p backends.Processor) backends.Processor {
+		return backends.ProcessWith(
+			func(e *mail.Envelope, task backends.SelectTask) (backends.Result, error) {
+				if task == backends.TaskSaveMail {
+
+					err := sendMail(e, config)
+					if err != nil {
+						fmt.Printf("!!! %v\n", err)
+						return backends.NewResult(fmt.Sprintf("554 Error: %s", err)), err
+					}
+
+					return p.Process(e, task)
+				}
+				return p.Process(e, task)
+			},
+		)
+	}
+}