SMTP daemon saving all mails to maildir

maildir-smtpd.go

package main

import (
	"os"
	"os/signal"
	"log"
	"github.com/flashmob/go-guerrilla/mail"
	"strings"
	"github.com/flashmob/go-maildir"
	"fmt"
	"path"
	"os/user"
	"syscall"
	"strconv"
	"github.com/flashmob/go-guerrilla/response"
	"errors"
	"github.com/flashmob/go-guerrilla/backends"
	"github.com/flashmob/go-guerrilla"
	"path/filepath"
	"time"
)

func main() {
	hostname := os.Getenv("SMTPD_HOSTNAME")
	if hostname == "" {
		hostname, _ = os.Hostname()
	}

	listenInterface := os.Getenv("SMTPD_LISTEN_INTERFACE")
	if listenInterface == "" {
		listenInterface = "0.0.0.0:25"
	}

	maildirRoot := os.Getenv("SMTPD_MAILDIR_ROOT")
	if maildirRoot == "" {
		if len(os.Args) < 2 {
			log.Fatalf("Usage: %s [<maildir_root>]\nYou can also configure using SMTPD_{MAILDIR_ROOT,LISTEN_INTERFACE,HOSTNAME,USER} env vars", filepath.Base(os.Args[0]))
			os.Exit(1)
		}
		maildirRoot = os.Args[1]
	}

	var mailboxUser *user.User;
	if mailboxUserName := os.Getenv("SMTPD_USER"); mailboxUserName != "" {
		var err error;
		if mailboxUser, err = user.Lookup(mailboxUserName); err != nil {
			log.Fatal("No such user: ", mailboxUserName)
		}
	}

	cfg := &guerrilla.AppConfig{
		LogFile: "stderr",
		AllowedHosts: []string{hostname},
		BackendConfig: backends.BackendConfig{
			"save_process" : "HeadersParser|Debugger|Hasher|ReceivedHeader|MailDirAny",
		},
		Servers:[]guerrilla.ServerConfig{
			{
				Hostname: hostname,
				ListenInterface: listenInterface,
				IsEnabled: true,
			},
		},
	}

	d := guerrilla.Daemon{Config: cfg}
	d.AddProcessor("ReceivedHeader", func() backends.Decorator {
		return func(c backends.Processor) backends.Processor {
			return backends.ProcessWith(func(e *mail.Envelope, task backends.SelectTask) (backends.Result, error) {
				if task == backends.TaskSaveMail {
					rcptTos := make([]string, len(e.RcptTo))
					for i := range e.RcptTo {
						rcptTos[i] = fmt.Sprintf("<%s@%s>", e.RcptTo[i].User, e.RcptTo[i].Host)
					}
					e.DeliveryHeader = fmt.Sprintf("Received: from %s (%s) by %s\n\tfor %s; %s (envelope-from <%s@%s>)\n",
						e.Helo, e.RemoteIP, hostname, strings.Join(rcptTos, ","),
						time.Now().Format(time.RFC1123Z), e.MailFrom.User, e.MailFrom.Host)
				}
				return c.Process(e, task)
			})
		}
	})
	d.AddProcessor("MailDirAny", func() backends.Decorator {
		return func(c backends.Processor) backends.Processor {
			return backends.ProcessWith(func(e *mail.Envelope, task backends.SelectTask) (backends.Result, error) {
				if task == backends.TaskSaveMail {
					for i := range e.RcptTo {
						u := strings.ToLower(e.RcptTo[i].User)
						backends.Log().Infof("Mail for %#v", u)
						if u == "." || u == ".." {
							return backends.NewResult(fmt.Sprintf("501 Invalid user %#v", u)), errors.New(response.Canned.FailInvalidAddress)
						}
						maildirPath := path.Join(maildirRoot, strings.Replace(u, "/", "_", -1))

						if mailboxUser != nil {
							gid, _ := strconv.Atoi(mailboxUser.Gid)
							uid, _ := strconv.Atoi(mailboxUser.Uid)

							if err := syscall.Setregid(gid, gid); err != nil {
								log.Fatal("Could not change to gid: ", gid, " - ", err)
							}
							if err := syscall.Setreuid(uid, uid); err != nil {
								log.Fatal("Could not change to uid: ", uid, " - ", err)
							}
						}

						if m, err := maildir.NewWithPerm(maildirPath, true, 0600, -1, -1); err != nil {
							backends.Log().WithError(err).Error("Could not create maildir at: ", maildirRoot)
							return backends.NewResult(fmt.Sprintf("554 Error: can't create mailbox for [%s]", u)), err
						} else {
							if filename, err := m.CreateMail(e.NewReader()); err != nil {
								backends.Log().WithError(err).Error("Could not save mail")
								return backends.NewResult(fmt.Sprintf("554 Error: could not save mail for [%s]", u)), err
							} else {
								backends.Log().Debug("Saved mail as: ", filename)
							}
						}
					}
				} else {
					backends.Log().Info("Task not supported: ", task)
				}
				return c.Process(e, task)
			})
		}
	})

	err := d.Start()
	if err == nil {
		c := make(chan os.Signal, 1)
		signal.Notify(c, os.Interrupt)
		s := <-c
		log.Fatal("Got signal: ", s)
	} else {
		log.Fatal(err)
	}
}

When did you learn Go language?