Fix ldapAttr typo

mxrouter.conf.sample

@@ -6,5 +6,5 @@ ldapPass here_lies_the_password
 # "domain" sera ajoute a relayName pour former le FQDN
 domain example.org
 # Le nom de l'attribut LDAP contenant le relais a retourner
-lapAttr relayName
+ldapAttr relayName
 

mxrouter.go

@@ -10,6 +10,7 @@
 // Use a single LDAP connection protected by a mutex
 //
 // v0.9.6 : add PID file
+// v0.9.8 : Check MX format with regex
 //
 
 package main
@@ -21,16 +22,21 @@ import (
 	"log/syslog"
 	"net"
 	"os"
+	"regexp"
 	"strings"
 	"sync"
+	"time"
 
 	"github.com/go-ldap/ldap/v3"
 	"github.com/peterbourgon/ff"
-  "github.com/tabalt/pidfile"
+	"github.com/tabalt/pidfile"
 )
 
 const (
-	version = "0.9.6"
+	version = "0.9.9"
+	// Match le nom de domaine, soit les 2 dernieres chaines separees par un point.
+	//  Peut aussi terminer par un point (Ex: srv.domaine.com. => domaine.com)
+	DomainRegexpFormat = `([0-9A-Za-z\-]*)\.([0-9A-Za-z\-]*)(?:\.)?$`
 )
 
 var (
@@ -45,123 +51,166 @@ var (
 	ldapPass    *string
 	ldapAttr    *string
 	defDomain   *string
-  pidFilePath *string
+	pidFilePath *string
+	timeout     *int
 )
 
+// attempt is useless now. It was introduced to break after N attempts, but this is not implemented. Should it be?
 func ldapSearch(searchReq *ldap.SearchRequest, attempt int) (*ldap.SearchResult, error) {
 	mutex.Lock()
 	result, err := conLdap.Search(searchReq)
 	mutex.Unlock()
 	// Let's just manage connection errors here
-	if err != nil && strings.HasSuffix(err.Error(), "ldap: connection closed") {
+	if err != nil {
-		logstream.Err("LDAP connection closed, retrying")
+		if strings.HasSuffix(err.Error(), "ldap: connection closed") {
-		mutex.Lock()
+			logstream.Err("LDAP connection closed, retrying")
-		conLdap.Close()
+			mutex.Lock()
-		conLdap, err = connectLdap()
+			conLdap.Close()
-		mutex.Unlock()
+			conLdap, err = connectLdap()
-		if err != nil {
+			mutex.Unlock()
-			return result, err
+			if err != nil {
-		} else {
+				return result, err
-			attempt = attempt + 1
+			} else {
-			return ldapSearch(searchReq, attempt)
+				attempt = attempt + 1
+				return ldapSearch(searchReq, attempt)
+			}
+		} else if err == ldap.ErrNilConnection {
+			logstream.Err("LDAP connection is nil, reconnecting")
+			mutex.Lock()
+			// conLdap is nil so this would be a sigsegv/panic
+			//conLdap.Close()
+			conLdap, err = connectLdap()
+			mutex.Unlock()
+			if err != nil {
+				return result, err
+			} else {
+				attempt = attempt + 1
+				return ldapSearch(searchReq, attempt)
+			}
 		}
 	}
 
 	return result, err
 }
 
+func sendResponse(con net.Conn, respMsg string, respCode int) error {
+	response := fmt.Sprintf("%d %s\n", respCode, strings.Replace(respMsg, " ", "%20", -1))
+	_, err := con.Write([]byte(response))
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func handleConnection(connClt net.Conn, conLdap *ldap.Conn) {
 	var s string
 	var mxdom string
+
 	buf := make([]byte, 1024)
 
-	defer connClt.Close()
+	re := regexp.MustCompile(DomainRegexpFormat)
-	readlen, err := connClt.Read(buf)
-	if err != nil {
-		fmt.Println("Error reading:", err.Error())
-	}
 
-	// 1) Recupere le MX du domaine de l'adresse mail recue
+	// Close connection when this function ends
-	if strings.HasPrefix(string(buf[:readlen-1]), "get ") && strings.Contains(string(buf[:readlen-1]), "@") {
+	defer func() {
-		mail := string(buf[4 : readlen-1])
+		logstream.Debug("Closing connection")
-		domain := strings.Split(mail, "@")[1]
+		connClt.Close()
-		mxs, err := net.LookupMX(domain)
+	}()
+
+	timeoutDuration := time.Duration(*timeout) * time.Second
+
+	for {
+		// Set a deadline for reading. Read operation will fail if no data
+		// is received after deadline.
+		connClt.SetReadDeadline(time.Now().Add(timeoutDuration))
+
+		readlen, err := connClt.Read(buf)
 		if err != nil {
-			logstream.Err(fmt.Sprintln("Error lookup mx: ", err))
+			// Dont notice if client closed connection
-			s := strings.Replace(fmt.Sprintf("Error lookup MX: %s", err.Error()), " ", "%20", -1)
+			if err.Error() != "EOF" && !strings.HasSuffix(err.Error(), "i/o timeout") {
-			response := fmt.Sprintf("500 %s\n", s)
+				logstream.Err(fmt.Sprintln("Error reading connection :", err.Error()))
-			connClt.Write([]byte(response))
-			return
-		}
-		// 2) Requete LDAP pour voir si le domaine de second niveau du MX possede un routage particulier
-		// Protection contre ca : example.org.            72      IN      MX      0 .
-		// Considerons qu'il n'y aura jamais de "one letter TLD"
-		if len(mxs[0].Host) < 4 {
-			logstream.Err(fmt.Sprintln("No usable mx found"))
-			s := strings.Replace("No usable MX found", " ", "%20", -1)
-			resp := fmt.Sprintf("500 %s\n", s)
-			connClt.Write([]byte(resp))
-			return
-		}
-
-		mxslic := strings.Split(mxs[0].Host, ".")
-		// les MXs terminent par '.', on le retire
-		if mxs[0].Host[len(mxs[0].Host)-1] == '.' {
-			mxdom = strings.Join(mxslic[len(mxslic)-3:len(mxslic)-1], ".")
-		} else {
-			mxdom = strings.Join(mxslic[len(mxslic)-2:len(mxslic)], ".")
-		}
-
-		filter := fmt.Sprintf("(dc=%s)", ldap.EscapeFilter(mxdom))
-		searchReq := ldap.NewSearchRequest(*ldapBaseDN, ldap.ScopeWholeSubtree, 0, 0, 0,
-			false, filter, []string{*ldapAttr}, []ldap.Control{})
-
-		result, err := ldapSearch(searchReq, 0)
-		if err != nil {
-			logstream.Err(fmt.Sprintln("Error searching into LDAP: ", err))
-			s := strings.Replace(err.Error(), " ", "%20", -1)
-			response := fmt.Sprintf("500 %s\n", s)
-			connClt.Write([]byte(response))
-			return
-		}
-
-		if len(result.Entries) != 1 {
-			if *debug {
-				logstream.Debug("Got no result, returning 500")
 			}
-			s := strings.Replace("No route defined", " ", "%20", -1)
-			response := fmt.Sprintf("500 %s\n", s)
-			connClt.Write([]byte(response))
 			return
 		}
 
-		// L'attribut n'existe pas
+		// 1) Recupere le MX du domaine de l'adresse mail recue
-		if len(result.Entries[0].Attributes) == 0 {
+		if strings.HasPrefix(string(buf[:readlen-1]), "get ") && strings.Contains(string(buf[:readlen-1]), "@") {
-			logstream.Err(fmt.Sprintf("Error searching into LDAP: Attribute %s not found for entry %s\n", *ldapAttr, result.Entries[0]))
+			mail := string(buf[4 : readlen-1])
-			s := strings.Replace(fmt.Sprintf("Attribute not found: %s", *ldapAttr), " ", "%20", -1)
+			domain := strings.Split(mail, "@")[1]
-			response := fmt.Sprintf("500 %s\n", s)
+			mxs, err := net.LookupMX(domain)
-			connClt.Write([]byte(response))
+			if err != nil {
-			return
+				logstream.Err(fmt.Sprintln("Error lookup mx: ", err))
-		}
+				s := fmt.Sprintf("Error lookup MX: %s", err.Error())
+				sendResponse(connClt, s, 500)
+				continue
+			}
+			// 2) Requete LDAP pour voir si le domaine de second niveau du MX possede un routage particulier
+			// Protection contre ca : example.org.            72      IN      MX      0 .
+			// Considerons qu'il n'y aura jamais de "one letter TLD"
+			if len(mxs[0].Host) < 4 {
+				logstream.Err(fmt.Sprintln("No usable mx found"))
+				s := "No usable MX found"
+				sendResponse(connClt, s, 500)
+				continue
+			}
 
-		if *debug {
+			// On recuperer le nom de domaine de 1er niveau
-			logstream.Debug("Got result, returning " + result.Entries[0].Attributes[0].Values[0])
+			group := re.FindSubmatch([]byte(mxs[0].Host))
-		}
+			if len(group) < 3 || len(group[2]) == 0 {
-		// Check if result is a FQDN, if not append defDomain
+				logstream.Err(fmt.Sprintln("MX format incorrect: ", mxs[0].Host))
-		if strings.Contains(string(result.Entries[0].Attributes[0].Values[0]), ".") {
+				s := fmt.Sprintf("MX format incorrect: %s", mxs[0].Host)
-			s = strings.Replace(fmt.Sprintf("FILTER relay:[%s]", result.Entries[0].Attributes[0].Values[0]), " ", "%20", -1)
+				sendResponse(connClt, s, 500)
+				continue
+			}
+			mxdom = string(group[1]) + "." + string(group[2])
+
+			filter := fmt.Sprintf("(dc=%s)", ldap.EscapeFilter(mxdom))
+			searchReq := ldap.NewSearchRequest(*ldapBaseDN, ldap.ScopeWholeSubtree, 0, 0, 0,
+				false, filter, []string{*ldapAttr}, []ldap.Control{})
+
+			result, err := ldapSearch(searchReq, 0)
+			if err != nil {
+				logstream.Err(fmt.Sprintln("Error searching into LDAP: ", err))
+				s := err.Error()
+				sendResponse(connClt, s, 500)
+				continue
+			}
+
+			if len(result.Entries) != 1 {
+				if *debug {
+					logstream.Debug("Got no result, returning 500")
+				}
+				s := "No route defined"
+				sendResponse(connClt, s, 500)
+				continue
+			}
+
+			// L'attribut n'existe pas
+			if len(result.Entries[0].Attributes) == 0 {
+				logstream.Err(fmt.Sprintf("Error searching into LDAP: Attribute %s not found for entry %s\n", *ldapAttr, result.Entries[0]))
+				s := fmt.Sprintf("Attribute not found: %s", *ldapAttr)
+				sendResponse(connClt, s, 500)
+				continue
+			}
+
+			if *debug {
+				logstream.Debug("Got result, returning " + result.Entries[0].Attributes[0].Values[0])
+			}
+			// Check if result is a FQDN, if not append defDomain
+			if strings.Contains(string(result.Entries[0].Attributes[0].Values[0]), ".") {
+				s = fmt.Sprintf("FILTER relay:[%s]", result.Entries[0].Attributes[0].Values[0])
+			} else {
+				s = fmt.Sprintf("FILTER relay:[%s]", fmt.Sprintf("%s.%s", result.Entries[0].Attributes[0].Values[0], *defDomain))
+			}
+			sendResponse(connClt, s, 200)
 		} else {
-			s = strings.Replace(fmt.Sprintf("FILTER relay:[%s]", fmt.Sprintf("%s.%s", result.Entries[0].Attributes[0].Values[0], *defDomain)), " ", "%20", -1)
+			if *debug {
+				logstream.Debug("Incorrect input format : " + string(buf[:readlen-1]))
+			}
+			s := "Incorrect input format"
+			sendResponse(connClt, s, 500)
+			continue
 		}
-		connClt.Write([]byte(fmt.Sprintf("200 %s\n", s)))
-	} else {
-		if *debug {
-			logstream.Debug("Incorrect input format : " + string(buf[:readlen-1]))
-		}
-		s := strings.Replace("Incorrect input format", " ", "%20", -1)
-		response := fmt.Sprintf("500 %s\n", s)
-		connClt.Write([]byte(response))
-		return
 	}
 }
 
@@ -217,7 +266,8 @@ func main() {
 	ldapPass = fs.String("ldapPass", "", "LDAP user password (also via LDAPPASS env var)")
 	ldapAttr = fs.String("ldapAttr", "relayName", "LDAP attribute containing the relay name to return")
 	defDomain = fs.String("domain", "", "Domain to add to relay name if not a FQDN (also via DOMAIN env var)")
-	pidFilePath= fs.String("pidfile", "/var/run/mxrouter/mxrouter.pid", "PID File (also via PIDFILE env var)")
+	pidFilePath = fs.String("pidfile", "/var/run/mxrouter/mxrouter.pid", "PID File (also via PIDFILE env var)")
+	timeout = fs.Int("timeout", 5, "timeout in seconds")
 	_ = fs.String("config", "", "config file (optional)")
 
 	// Surcharge de la fonction Usage()
@@ -233,11 +283,11 @@ func main() {
 		return
 	}
 
-  if pid, err := pidfile.Create(*pidFilePath); err != nil {
+	if pid, err := pidfile.Create(*pidFilePath); err != nil {
-    log.Fatal(err)
+		log.Fatal(err)
-  } else {
+	} else {
-    defer pid.Clear()
+		defer pid.Clear()
-  }
+	}
 
 	if logstream, e = syslog.New(syslog.LOG_MAIL, "mxrouter"); e != nil {
 		log.Fatal(e)