346 lines
11 KiB
Go
346 lines
11 KiB
Go
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"
|
|
"os"
|
|
"os/exec"
|
|
"io"
|
|
"path/filepath"
|
|
"strings"
|
|
"log/syslog"
|
|
)
|
|
|
|
const VERSION = "1.0.0001"
|
|
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 nil
|
|
}
|
|
|
|
// Forward email using supplied arguments and stdin (email body)
|
|
func forwardEmailAndAutoresponse(recipient, sender, saslUser, clientIp string, responseRate uint) error {
|
|
//!!!
|
|
|
|
return nil
|
|
}
|
|
|
|
// Enable autoresponse for email
|
|
func enableAutoresponse(email string) error {
|
|
//!!!
|
|
|
|
return nil
|
|
}
|
|
|
|
// Disable autoresponse for email
|
|
func disableAutoresponse(email string) error {
|
|
//!!!
|
|
|
|
return nil
|
|
}
|
|
|
|
// Enable existing autoresponse for email
|
|
func enableExAutoresponse(email string) error {
|
|
//!!!
|
|
|
|
return nil
|
|
}
|
|
|
|
// Delete autoresponse for email
|
|
func deleteAutoresponse(email string, nostdout bool) error {
|
|
deleteResponsePath := filepath.Join(RESPONSE_DIR, email)
|
|
if fileExists(deleteResponsePath) {
|
|
os.Remove(deleteResponsePath)
|
|
} 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
|
|
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)")
|
|
flag.Parse()
|
|
|
|
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
|
|
sendResponse := false
|
|
authenticated := false
|
|
if *recipientPtr != "" && *senderPtr != "" {
|
|
sendResponse = true
|
|
}
|
|
if *saslUserPtr != "" {
|
|
authenticated = true
|
|
}
|
|
if *enableAutoResponsePtr != "" || *disableAutoResponsePtr != "" || *enableExAutoResponsePtr != "" || *deleteAutoResponsePtr != "" {
|
|
mode = 1
|
|
}
|
|
DebugSyslogFmt("mode=%v, sendResponse=%v, authenticated=%v\n", mode, sendResponse, 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 len(recipientParts) < 2 {
|
|
syslg.Err(fmt.Sprintf("Invalid recipient %v", *recipientPtr))
|
|
os.Exit(1)
|
|
}
|
|
if 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)
|
|
//!!!
|
|
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)
|
|
}
|
|
}
|
|
//!!!
|
|
}
|