package main

// This is postfix autoresponder, which is rewrite of the autoresponder bash script V1.6.3, written by Charles Hamilton - musashi@nefaria.com
//
// How to make it work on a server with postfix installed:
// =======================================================
// Create autoresponder username:
// useradd -d /var/spool/autoresponder -s $(which nologin) autoresponder
//
// Copy autoresponder binary to /usr/local/sbin
// cp autoresponder /usr/local/sbin/
//
// RESPONSE_DIR, RATE_LOG_DIR must be created:
// mkdir -p /var/spool/autoresponder/log /var/spool/autoresponder/responses
// chown -R autoresponder:autoresponder /var/spool/autoresponder
// chmod -R 0770 /var/spool/autoresponder
//
// Edit /etc/postfix/master.cf:
// Replace line:
// smtp inet n - - - - smtpd
// with these two lines (second must begin with at least one space or tab):
// smtp inet n - - - - smtpd
//   -o content_filter=autoresponder:dummy
// At the end of file append the following two lines:
// autoresponder unix - n n - - pipe
//   flags=Fq user=autoresponder argv=/usr/local/sbin/autoresponder -s ${sender} -r ${recipient} -S ${sasl_username} -C ${client_address}
//
//
// Written by Uros Juvan <asmpro@gmail.com> 2017

import (
    "fmt"
    "flag"
    "time"
    "os"
    "os/exec"
    "io"
    "io/ioutil"
    "bufio"
    "path/filepath"
    "strings"
    "log/syslog"
)

const VERSION = "1.0.0003"
const DEBUG = true

const RESPONSE_DIR = "/var/spool/autoresponder/responses"
const RATE_LOG_DIR = "/var/spool/autoresponder/log"
const SENDMAIL_BIN = "/usr/sbin/sendmail"


var syslg *syslog.Writer = nil


// Function using fmt.Printf for debug printing, but only if DEBUG is true
func DebugFmtPrintf(format string, v ...interface{})  {
        if DEBUG {
                fmt.Printf("DEBUG: " + format, v...)
        }
}
func DebugSyslogFmt(format string, v ...interface{})  {
        if syslg == nil {
            return
        }
        if DEBUG {
                syslg.Debug(fmt.Sprintf("DEBUG: " + format, v...))
        }
}

// Return true if file exists and is regular file
func fileExists(name string) bool {
    st, err := os.Lstat(name)
    if err != nil || (st.Mode() & os.ModeType) != os.FileMode(0) {
        return false
    }

    return true
}

// Send mail from address to address with given mail content being passed as function pointer
func sendMail(from, to string, populateStdin func(io.WriteCloser)) error {
    cmd := exec.Command(SENDMAIL_BIN, "-i", "-f", from, to)
    stdin, err := cmd.StdinPipe()
    if err != nil {
        return err
    }
    err = cmd.Start()
    if err != nil {
        return err
    }
    go func() {
        populateStdin(stdin)
    }()
    err = cmd.Wait()
    if err != nil {
        return err
    }

    return nil
}

// Set autoresponse using supplied arguments and stdin (email body)
func setAutoresponseViaEmail(recipient, sender, saslUser, clientIp string) error {
    senderResponsePath := filepath.Join(RESPONSE_DIR, sender)
    if fileExists(senderResponsePath) {
        err := deleteAutoresponse(sender, true)
        if err != nil {
            return err
        }

        if ! fileExists(senderResponsePath) {
            syslg.Info(fmt.Sprintf("Autoresponse disabled for address %v by SASL authenticated user: %v from: %v",
                sender, saslUser, clientIp))
            // Send mail via sendmail
            sendMail(recipient, sender, func(sink io.WriteCloser) {
                defer sink.Close()

                sink.Write([]byte(fmt.Sprintf("From: %v\nTo: %v\nSubject: Autoresponder\n\n"+
                    "Autoresponse disabled for %v by SASL authenticated user: %v from: %v\n",
                    recipient, sender, sender, saslUser, clientIp)))
            })
        } else {
            return fmt.Errorf("Autoresponse could not be disabled for address %v", sender)
        }
    } else {
        // Cat stdin to response file for the user, removing unneeded headers in the process
        // Only From:, To: and Subject: are needed.
        // To: ... is replaced with To: THIS GETS REPLACED
        // Subject: ... is replaced with Subject: Autoresponder
        fl, err := os.OpenFile(senderResponsePath, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0660)
        if err != nil {
            return fmt.Errorf("Autoresponse could not be enabled for address %v: %v", sender, err)
        }
        fl.Chmod(0660)
        reader := bufio.NewReader(os.Stdin)
        writer := bufio.NewWriter(fl)
        defer func() {
            writer.Flush()
            fl.Close()
        }()
        state := 0
        for {
            line, err := reader.ReadString('\n')
            if err != nil {
                if err == io.EOF {
                    break
                }
                return err
            }
            //fmt.Printf("Read line: '%v'\n", line)

            switch state {
            // state 0 (mail header)
            case 0:
                if line == "\n" || line == "\r\n" || line == "\r" {
                    _, err = writer.WriteString(line)
                    state = 1
                    continue
                }

                switch true {
                case strings.Index(strings.ToLower(line), "from: ") == 0 ||
                    strings.Index(strings.ToLower(line), "content-type: ") == 0 ||
                    strings.Index(strings.ToLower(line), "content-transfer-encoding: ") == 0 ||
                    strings.Index(strings.ToLower(line), "mime-version: ") == 0:
                    _, err = writer.WriteString(line)

                case strings.Index(strings.ToLower(line), "to: ") == 0:
                    _, err = writer.WriteString("To: THIS GETS REPLACED\n")

                case strings.Index(strings.ToLower(line), "subject: ") == 0:
                    _, err = writer.WriteString("Subject: Autoresponder\n")
                }

            case 1:
                _, err = writer.WriteString(line)
            }

            if err != nil {
                return err
            }
        }

        if fileExists(senderResponsePath) {
            syslg.Info(fmt.Sprintf("Autoresponse enabled for address %v by SASL authenticated user: %v from: %v",
                sender, saslUser, clientIp))
            // Send mail via sendmail
            sendMail(recipient, sender, func(sink io.WriteCloser) {
                defer sink.Close()
                sink.Write([]byte(fmt.Sprintf("From: %v\nTo: %v\nSubject: Autoresponder\n\n"+
                    "Autoresponse enabled for %v by SASL authenticated user: %v from: %v\n",
                    recipient, sender, sender, saslUser, clientIp)))
            })
        } else {
            return fmt.Errorf("Autoresponse could not be enabled for address %v", sender)
        }
    }

    return nil
}

// Forward email using supplied arguments and stdin (email body)
func forwardEmailAndAutoresponse(recipient, sender, saslUser, clientIp string, responseRate uint) error {
    recipientResponsePath := filepath.Join(RESPONSE_DIR, recipient)
    recipientRateLog := filepath.Join(RATE_LOG_DIR, recipient)
    recipientSenderRateLog := filepath.Join(RATE_LOG_DIR, recipient, sender)

    if fileExists(recipientResponsePath) {
        // Check rate log
        sendResponse := true
        if fileExists(recipientSenderRateLog) {
            curTime := time.Now()
            st, err := os.Stat(recipientSenderRateLog)
            if err != nil {
                return err
            }
            modTime := st.ModTime()

            if int64(curTime.Sub(modTime)) / int64(time.Second) < int64(responseRate) {
                sendResponse = false
                syslg.Info(fmt.Sprintf("Autoresponse has already been sent from %v to %v within last %v seconds",
                    recipient, sender, responseRate))
            }
        }

        // If sendResponse is true and sender and recipiend differ, then send response and touch rate log file
        if sendResponse && strings.ToLower(recipient) != strings.ToLower(sender) {
            //fmt.Println("Sending response")
            fl, err := os.Open(recipientResponsePath)
            if err != nil {
                return err
            }
            defer fl.Close()
            sendMail(recipient, sender, func(sink io.WriteCloser) {
                defer sink.Close()

                // Open recipientResponsePath file and do some replacements on the fly
                reader := bufio.NewReader(fl)
                state := 0
                for {
                    line, err := reader.ReadString('\n')
                    if err != nil {
                        if err == io.EOF {
                            break
                        }
                        syslg.Err(err.Error())
                        return
                    }

                    switch state {
                    case 0:
                        switch true {
                        case line == "\n" || line == "\r\n" || line == "\r":
                            state = 1

                        case strings.Index(strings.ToLower(line), "from: ") == 0:
                            line = fmt.Sprintf("From: %v\n", recipient)

                        case strings.Index(strings.ToLower(line), "to: ") == 0:
                            line = fmt.Sprintf("To: %v\n", sender)
                        }
                        fallthrough

                    default:
                        sink.Write([]byte(line))
                    }
                }
            })
            err = os.MkdirAll(recipientRateLog, 0770)
            if err != nil {
                return err
            }
            // Touch rate log file
            fl, err = os.Create(recipientSenderRateLog)
            if err != nil {
                return err
            }
            fl.Close()
            syslg.Info(fmt.Sprintf("Autoresponse sent from %v to %v", recipient, sender))
        }
    }

    // Now resend original mail
    sendMail(sender, recipient, func(sink io.WriteCloser) {
        defer sink.Close()

        io.Copy(sink, os.Stdin)
    })

    return nil
}

// Get text editor
func getTextEditor() string {
    editor := os.Getenv("EDITOR")
    if editor == "" {
        editor = "vi"
    }

    return editor
}

// Get file modification time
func getFileModTime(name string) (t time.Time, err error) {
    st, err := os.Stat(name)
    if err != nil {
        return t, err
    }
    t = st.ModTime()

    return
}

// Enable autoresponse for email
func enableAutoresponse(email string) error {
    emailResponsePath := filepath.Join(RESPONSE_DIR, email)
    editFilePath := emailResponsePath

    // If editFilePath does not exist, also try to enable previosly disabled autoresponse
    if ! fileExists(editFilePath) {
        enableExAutoresponse(email, true)
    }

    // If file does not exist yet, create template file as tmp file
    var oldModTime, newModTime time.Time
    if ! fileExists(editFilePath) {
        editFile, err := ioutil.TempFile("", "autoresponder")
        if err != nil {
            return err
        }
        editFilePath = editFile.Name()
        defer os.Remove(editFilePath)

        writer := bufio.NewWriter(editFile)

        // Write template to file
        writer.WriteString(fmt.Sprintf(`From: %v
To: THIS GETS REPLACED
Content-Type: text/plain; charset=UTF-8
Subject: Autoresponder

mail body`, email))

        writer.Flush()
        editFile.Close()
    }
    oldModTime, err := getFileModTime(editFilePath)
    if err != nil {
        return err
    }

    // Invoke either EDITOR environment or vi command
    cmd := exec.Command(getTextEditor(), editFilePath)
    cmd.Stdin = os.Stdin
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    err = cmd.Run()
    if err != nil {
        return err
    }

    newModTime, err = getFileModTime(editFilePath)
    if err != nil {
        return err
    }

    if oldModTime != newModTime {
        if emailResponsePath != editFilePath {
            // Open editFilePath for reading and emailResponsePath for writing and Copy content over
            tmpFl, err := os.Open(editFilePath)
            if err != nil {
                return err
            }
            defer tmpFl.Close()

            resFl, err := os.OpenFile(emailResponsePath, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0660)
            if err != nil {
                return err
            }
            resFl.Chmod(0660)
            defer resFl.Close()

            _, err = io.Copy(resFl, tmpFl)
            if err != nil {
                return err
            }
        }
        msg := fmt.Sprintf("Edited %v", emailResponsePath)
        syslg.Info(msg)
        fmt.Println(msg)
    } else {
        msg := fmt.Sprintf("Editing %v aborted!", emailResponsePath)
        fmt.Println(msg)
        return fmt.Errorf("%v", msg)
    }

    return nil
}

// Disable autoresponse for email
func disableAutoresponse(email string) error {
    emailResponsePath := filepath.Join(RESPONSE_DIR, email)

    if fileExists(emailResponsePath) {
        disableEmailResponsePath := emailResponsePath + "_DISABLED"
        os.Remove(disableEmailResponsePath)
        err := os.Rename(emailResponsePath, disableEmailResponsePath)
        if err != nil {
            return err
        }
        msg := fmt.Sprintf("Disabled %v", emailResponsePath)
        syslg.Info(msg)
        fmt.Println(msg)
    } else {
        msg := fmt.Sprintf("%v does not exist, thus it cannot be disabled!", emailResponsePath)
        fmt.Println(msg)
        return fmt.Errorf("%v", msg)
    }

    return nil
}

// Enable existing autoresponse for email
func enableExAutoresponse(email string, nostdout bool) error {
    emailResponsePath := filepath.Join(RESPONSE_DIR, email)
    disableEmailResponsePath := emailResponsePath + "_DISABLED"

    if fileExists(disableEmailResponsePath) {
        os.Remove(emailResponsePath)
        err := os.Rename(disableEmailResponsePath, emailResponsePath)
        if err != nil {
            return err
        }
        msg := fmt.Sprintf("Enabled %v", emailResponsePath)
        syslg.Info(msg)
        fmt.Println(msg)
    } else {
        msg := fmt.Sprintf("%v does not exist, thus it cannot be enabled!", disableEmailResponsePath)
        if ! nostdout {
            fmt.Println(msg)
        }
        return fmt.Errorf("%v", msg)
    }

    return nil
}

// Delete autoresponse for email
func deleteAutoresponse(email string, nostdout bool) error {
    deleteResponsePath := filepath.Join(RESPONSE_DIR, email)
    disabledDeleteResponsePath := deleteResponsePath + "_DISABLED"
    recipientRateLog := filepath.Join(RATE_LOG_DIR, email)

    if fileExists(deleteResponsePath) {
        os.Remove(disabledDeleteResponsePath)
        os.RemoveAll(recipientRateLog)
        err := os.Remove(deleteResponsePath)
        if err != nil {
            msg := fmt.Sprintf("%v cannot be deleted: %v", deleteResponsePath, err)
            if ! nostdout {
                fmt.Println(msg)
            }
            return fmt.Errorf("%v", msg)
        }
        msg := fmt.Sprintf("Delete %v done", deleteResponsePath)
        if ! nostdout {
            fmt.Println(msg)
        }
        syslg.Info(msg)
    } else {
        msg := fmt.Sprintf("%v does not exist, thus it cannot be deleted!", deleteResponsePath)
        if ! nostdout {
            fmt.Println(msg)
        }
        return fmt.Errorf("%v", msg)
    }

    return nil
}

func main() {
    // Connect to syslog
    var err error
    syslg, err = syslog.New(syslog.LOG_MAIL, "autoresponder")
    if err != nil {
        fmt.Println(err.Error())
        os.Exit(1)
    }
    defer syslg.Close()

    // Parse command line arguments
    recipientPtr := flag.String("r", "", "Recipient e-mail")
    senderPtr := flag.String("s", "", "Sender e-mail")
    saslUserPtr := flag.String("S", "", "SASL authenticated username")
    clientIpPtr := flag.String("C", "", "Client IP address")
    enableAutoResponsePtr := flag.String("e", "", "Enable autoresponse")
    disableAutoResponsePtr := flag.String("d", "", "Disable autoresponse")
    enableExAutoResponsePtr := flag.String("E", "", "Enable existing autoresponse")
    deleteAutoResponsePtr := flag.String("D", "", "Delete autoresponse")
    instructionsPtr := flag.Bool("i", false, "Setup instructions")
    responseRatePtr := flag.Uint("t", 86400, "Response rate in seconds (0 - send each time)")
    showVersion := flag.Bool("V", false, "Show version and exit")
    flag.Parse()

    if *showVersion {
        fmt.Printf("autoresponder %v, written by Uros Juvan <asmpro@gmail.com> 2017\n", VERSION)
        os.Exit(0)
    }

    DebugSyslogFmt("Flags:   Recipient: %v, Sender: %v, SASL authenticated username: %v, Client IP: %v, Enable autoresponse: %v, Disable autoresponse: %v, Enable existing autoresponse: %v, Delete autoresponse: %v, Setup instructions: %v, Response rate: %v",
        *recipientPtr,
        *senderPtr,
        *saslUserPtr,
        *clientIpPtr,
        *enableAutoResponsePtr,
        *disableAutoResponsePtr,
        *enableExAutoResponsePtr,
        *deleteAutoResponsePtr,
        *instructionsPtr,
        *responseRatePtr)

    // If setup instructions are requested, just print them to stdout and exit
    if *instructionsPtr {
        fmt.Print(`
 How to make it work on a server with postfix installed:
 =======================================================
 Create autoresponder username:
 useradd -d /var/spool/autoresponder -s $(which nologin) autoresponder

 Copy autoresponder binary to /usr/local/sbin
 cp autoresponder /usr/local/sbin/

 RESPONSE_DIR, RATE_LOG_DIR must be created:
 mkdir -p /var/spool/autoresponder/log /var/spool/autoresponder/responses
 chown -R autoresponder:autoresponder /var/spool/autoresponder
 chmod -R 0770 /var/spool/autoresponder

 Edit /etc/postfix/master.cf:
 Replace line:
 smtp inet n - - - - smtpd
 with these two lines (second must begin with at least one space or tab):
 smtp inet n - - - - smtpd
   -o content_filter=autoresponder:dummy
 At the end of file append the following two lines:
 autoresponder unix - n n - - pipe
   flags=Fq user=autoresponder argv=/usr/local/sbin/autoresponder -s ${sender} -r ${recipient} -S ${sasl_username} -C ${client_address}
`)
        os.Exit(0)
    }

    // Do some logic on command line arguments
    // Mode 
    // There are two different modes of operation:
    //	mode=0 represents the actions that can not be executed from the command line
    //	mode=1 represents the actions that can be executed from the command line
    mode := 0
    authenticated := false
    if *saslUserPtr != "" {
        authenticated = true
    }
    if *enableAutoResponsePtr != "" || *disableAutoResponsePtr != "" || *enableExAutoResponsePtr != "" || *deleteAutoResponsePtr != "" {
        mode = 1
    }
    DebugSyslogFmt("mode=%v, authenticated=%v\n", mode, authenticated)

    // Little more validation of recipient and sender
    // Remove path ('/') from both recipient and sender
    *recipientPtr = strings.Replace(*recipientPtr, "/", "", -1)
    *senderPtr = strings.Replace(*senderPtr, "/", "", -1)
    recipientParts := strings.Split(*recipientPtr, "@")
    senderParts := strings.Split(*senderPtr, "@")
    if *recipientPtr != "" && len(recipientParts) < 2 {
        syslg.Err(fmt.Sprintf("Invalid recipient %v", *recipientPtr))
        os.Exit(1)
    }
    if *senderPtr != "" && len(senderParts) < 2 {
        syslg.Err(fmt.Sprintf("Invalid sender %v", *senderPtr))
        os.Exit(1)
    }

    // And now descision making
    DebugSyslogFmt("recipientUser=%v =? senderUser=%v\n", recipientParts[0], senderParts[0] + "+autoresponse")
    switch true {
    //   - (un)set autoresponse via email
    case mode == 0 && recipientParts[0] == senderParts[0] + "+autoresponse":
        syslg.Info(fmt.Sprintf("Requested autoresponse (un)set via email for email %v", *senderPtr))

        // Do not allow unauthenticated changes
        if ! authenticated {
            syslg.Warning(fmt.Sprintf("Unauthenticated attempt to set autoresponse message for %v from %v !",
                *senderPtr, *clientIpPtr))
            os.Exit(0)
        }

        err := setAutoresponseViaEmail(*recipientPtr, *senderPtr, *saslUserPtr, *clientIpPtr)
        if err != nil {
            syslg.Err(err.Error())
            os.Exit(1)
        }

    //  - forward mail and either send response if set and enough time has passed
    case mode == 0 && strings.Index(*recipientPtr, "+autoresponse") == -1:
        syslg.Info(fmt.Sprintf("Requested email forward from %v, to %v", *senderPtr, *recipientPtr))

        err := forwardEmailAndAutoresponse(*recipientPtr, *senderPtr, *saslUserPtr, *clientIpPtr, *responseRatePtr)
        if err != nil {
            syslg.Err(err.Error())
            os.Exit(1)
        }

    //  - set autoresponse via cli
    case mode == 1 && *enableAutoResponsePtr != "":
        syslg.Info(fmt.Sprintf("Requested enable autoresponse for %v", *enableAutoResponsePtr))

        err := enableAutoresponse(*enableAutoResponsePtr)
        if err != nil {
            syslg.Err(err.Error())
            os.Exit(1)
        }

    //  - disable autoresponse via cli
    case mode == 1 && *disableAutoResponsePtr != "":
        syslg.Info(fmt.Sprintf("Requested disable autoresponse for %v", *disableAutoResponsePtr))

        err := disableAutoresponse(*disableAutoResponsePtr)
        if err != nil {
            syslg.Err(err.Error())
            os.Exit(1)
        }

    //  - enable existing autoresponse via cli
    case mode == 1 && *enableExAutoResponsePtr != "":
        syslg.Info(fmt.Sprintf("Requested enable existing autoresponse for %v", *enableExAutoResponsePtr))

        err := enableExAutoresponse(*enableExAutoResponsePtr, false)
        if err != nil {
            syslg.Err(err.Error())
            os.Exit(1)
        }

    //  - delete existing autoresponse via cli
    case mode == 1 && *deleteAutoResponsePtr != "":
        syslg.Info(fmt.Sprintf("Requested delete autoresponse for %v", *deleteAutoResponsePtr))

        err := deleteAutoresponse(*deleteAutoResponsePtr, false)
        if err != nil {
            syslg.Err(err.Error())
            os.Exit(1)
        }
    }
}