refactoring: protocol types gets a formal type & other small renames

backends/p_guerrilla_db_redis.go

@@ -440,17 +440,10 @@ func GuerrillaDbRedis() Decorator {
 				e.QueuedId = hash
 
 				// Add extra headers
-				protocol := "SMTP"
-				if e.ESMTP {
-					protocol = "E" + protocol
-				}
-				if e.TLS {
-					protocol = protocol + "S"
-				}
 				var addHead string
 				addHead += "Delivered-To: " + to + "\r\n"
 				addHead += "Received: from " + e.RemoteIP + " ([" + e.RemoteIP + "])\r\n"
-				addHead += "	by " + e.RcptTo[0].Host + " with " + protocol + " id " + hash + "@" + e.RcptTo[0].Host + ";\r\n"
+				addHead += "	by " + e.RcptTo[0].Host + " with " + e.Protocol().String() + " id " + hash + "@" + e.RcptTo[0].Host + ";\r\n"
 				addHead += "	" + time.Now().Format(time.RFC1123Z) + "\r\n"
 
 				// data will be compressed when printed, with addHead added to beginning

backends/p_header.go

@@ -54,18 +54,11 @@ func Header() Decorator {
 				if len(e.Hashes) > 0 {
 					hash = e.Hashes[0]
 				}
-				protocol := "SMTP"
-				if e.ESMTP {
-					protocol = "E" + protocol
-				}
-				if e.TLS {
-					protocol = protocol + "S"
-				}
 				var addHead string
 				addHead += "Delivered-To: " + to + "\n"
 				addHead += "Received: from " + e.RemoteIP + " ([" + e.RemoteIP + "])\n"
 				if len(e.RcptTo) > 0 {
-					addHead += "	by " + e.RcptTo[0].Host + " with " + protocol + " id " + hash + "@" + e.RcptTo[0].Host + ";\n"
+					addHead += "	by " + e.RcptTo[0].Host + " with " + e.Protocol().String() + " id " + hash + "@" + e.RcptTo[0].Host + ";\n"
 				}
 				addHead += "	" + time.Now().Format(time.RFC1123Z) + "\n"
 				// save the result

chunk/processor.go

@@ -157,7 +157,7 @@ func Chunksaver() *backends.StreamDecorator {
 					e.RcptTo[0].String(),
 					ip,
 					e.MailFrom.String(),
-					e.TLS,
+					e.Protocol(),
 					e.TransportType,
 				)
 				if err != nil {

chunk/store.go

@@ -2,6 +2,7 @@ package chunk
 
 import (
 	"github.com/flashmob/go-guerrilla/backends"
+	"github.com/flashmob/go-guerrilla/mail"
 	"github.com/flashmob/go-guerrilla/mail/smtp"
 	"io"
 	"net"
@@ -15,9 +16,23 @@ func init() {
 // Storage defines an interface to the storage layer (the database)
 type Storage interface {
 	// OpenMessage is used to begin saving an email. An email id is returned and used to call CloseMessage later
-	OpenMessage(from string, helo string, recipient string, ipAddress net.IPAddr, returnPath string, isTLS bool, transport smtp.TransportType) (mailID uint64, err error)
+	OpenMessage(
+		from string,
+		helo string,
+		recipient string,
+		ipAddress net.IPAddr,
+		returnPath string,
+		protocol mail.Protocol,
+		transport smtp.TransportType) (mailID uint64, err error)
 	// CloseMessage finalizes the writing of an email. Additional data collected while parsing the email is saved
-	CloseMessage(mailID uint64, size int64, partsInfo *PartsInfo, subject string, deliveryID string, to string, from string) error
+	CloseMessage(
+		mailID uint64,
+		size int64,
+		partsInfo *PartsInfo,
+		subject string,
+		queuedID string,
+		to string,
+		from string) error
 	// AddChunk saves a chunk of bytes to a given hash key
 	AddChunk(data []byte, hash []byte) error
 	// GetEmail returns an email that's been saved
@@ -47,13 +62,13 @@ type Email struct {
 	partsInfo  PartsInfo
 	helo       string // helo message given by the client when the message was transmitted
 	subject    string // subject stores the value from the first "Subject" header field
-	deliveryID string
+	queuedID   string
 	recipient  string             // recipient is the email address that the server received from the RCPT TO command
 	ipv4       net.IPAddr         // set to a value if client connected via ipv4
 	ipv6       net.IPAddr         // set to a value if client connected via ipv6
 	returnPath string             // returnPath is the email address that the server received from the MAIL FROM command
-	isTLS      bool               // isTLS is true when TLS was used to connect
-	transport  smtp.TransportType // did the sender signal 8bitmime?
+	protocol   mail.Protocol      // protocol such as SMTP, ESTMP, ESMTPS
+	transport  smtp.TransportType // transport what type of transport the message uses, eg 8bitmime
 }
 
 type Chunk struct {

chunk/store_memory.go

@@ -5,6 +5,7 @@ import (
 	"compress/zlib"
 	"errors"
 	"github.com/flashmob/go-guerrilla/backends"
+	"github.com/flashmob/go-guerrilla/mail"
 	"github.com/flashmob/go-guerrilla/mail/smtp"
 	"net"
 	"time"
@@ -20,6 +21,7 @@ type storeMemoryConfig struct {
 	CompressLevel int `json:"compress_level,omitempty"`
 }
 
+// A StoreMemory stores emails and chunked data in mememory
 type StoreMemory struct {
 	chunks        map[HashKey]*memoryChunk
 	emails        []*memoryEmail
@@ -38,13 +40,13 @@ type memoryEmail struct {
 	partsInfo  []byte
 	helo       string
 	subject    string
-	deliveryID string
+	queuedID   string
 	recipient  string
 	ipv4       net.IPAddr
 	ipv6       net.IPAddr
 	returnPath string
-	isTLS      bool
-	is8Bit     smtp.TransportType
+	transport  smtp.TransportType
+	protocol   mail.Protocol
 }
 
 type memoryChunk struct {
@@ -54,7 +56,15 @@ type memoryChunk struct {
 }
 
 // OpenMessage implements the Storage interface
-func (m *StoreMemory) OpenMessage(from string, helo string, recipient string, ipAddress net.IPAddr, returnPath string, isTLS bool, transport smtp.TransportType) (mailID uint64, err error) {
+func (m *StoreMemory) OpenMessage(
+	from string,
+	helo string,
+	recipient string,
+	ipAddress net.IPAddr,
+	returnPath string,
+	protocol mail.Protocol,
+	transport smtp.TransportType,
+) (mailID uint64, err error) {
 	var ip4, ip6 net.IPAddr
 	if ip := ipAddress.IP.To4(); ip != nil {
 		ip4 = ipAddress
@@ -70,8 +80,8 @@ func (m *StoreMemory) OpenMessage(from string, helo string, recipient string, ip
 		ipv4:       ip4,
 		ipv6:       ip6,
 		returnPath: returnPath,
-		isTLS:      isTLS,
-		is8Bit:     transport,
+		transport:  transport,
+		protocol:   protocol,
 	}
 	m.emails = append(m.emails, &email)
 	m.nextID++
@@ -79,7 +89,14 @@ func (m *StoreMemory) OpenMessage(from string, helo string, recipient string, ip
 }
 
 // CloseMessage implements the Storage interface
-func (m *StoreMemory) CloseMessage(mailID uint64, size int64, partsInfo *PartsInfo, subject string, deliveryID string, to string, from string) error {
+func (m *StoreMemory) CloseMessage(
+	mailID uint64,
+	size int64,
+	partsInfo *PartsInfo,
+	subject string,
+	queuedID string,
+	to string,
+	from string) error {
 	if email := m.emails[mailID-m.offset]; email == nil {
 		return errors.New("email not found")
 	} else {
@@ -90,7 +107,7 @@ func (m *StoreMemory) CloseMessage(mailID uint64, size int64, partsInfo *PartsIn
 			email.partsInfo = info
 		}
 		email.subject = subject
-		email.deliveryID = deliveryID
+		email.queuedID = queuedID
 		email.to = to
 		email.from = from
 		email.size = size
@@ -179,13 +196,13 @@ func (m *StoreMemory) GetEmail(mailID uint64) (*Email, error) {
 		partsInfo:  *pi,
 		helo:       email.helo,
 		subject:    email.subject,
-		deliveryID: email.deliveryID,
+		queuedID:   email.queuedID,
 		recipient:  email.recipient,
 		ipv4:       email.ipv4,
 		ipv6:       email.ipv6,
 		returnPath: email.returnPath,
-		isTLS:      email.isTLS,
-		transport:  email.is8Bit,
+		transport:  email.transport,
+		protocol:   email.protocol,
 	}, nil
 }
 

chunk/store_sql.go

@@ -5,6 +5,7 @@ import (
 	"encoding/binary"
 	"encoding/json"
 	"github.com/flashmob/go-guerrilla/backends"
+	"github.com/flashmob/go-guerrilla/mail"
 	"github.com/flashmob/go-guerrilla/mail/smtp"
 	"net"
 )
@@ -53,7 +54,7 @@ func (s *StoreSQL) prepareSql() error {
 	// begin inserting an email (before saving chunks)
 	if stmt, err := s.db.Prepare(`INSERT INTO ` +
 		s.config.EmailTable +
-		` (from, helo, recipient, ipv4_addr, ipv6_addr, return_path, is_tls, is_8bit) 
+		` (from, helo, recipient, ipv4_addr, ipv6_addr, return_path, transport, protocol) 
  VALUES(?, ?, ?, ?, ?, ?, ?, ?)`); err != nil {
 		return err
 	} else {
@@ -73,7 +74,7 @@ func (s *StoreSQL) prepareSql() error {
 	// finalize the email (the connection closed)
 	if stmt, err := s.db.Prepare(`
 		UPDATE ` + s.config.EmailTable + ` 
-			SET size=?, parts_info = ?, subject, delivery_id = ?, to = ? 
+			SET size=?, parts_info = ?, subject, queued_id = ?, to = ? 
 		WHERE mail_id = ? `); err != nil {
 		return err
 	} else {
@@ -131,7 +132,15 @@ func (s *StoreSQL) prepareSql() error {
 }
 
 // OpenMessage implements the Storage interface
-func (s *StoreSQL) OpenMessage(from string, helo string, recipient string, ipAddress net.IPAddr, returnPath string, isTLS bool, transport smtp.TransportType) (mailID uint64, err error) {
+func (s *StoreSQL) OpenMessage(
+	from string,
+	helo string,
+	recipient string,
+	ipAddress net.IPAddr,
+	returnPath string,
+	protocol mail.Protocol,
+	transport smtp.TransportType,
+) (mailID uint64, err error) {
 
 	// if it's ipv4 then we want ipv6 to be 0, and vice-versa
 	var ip4 uint32
@@ -141,7 +150,7 @@ func (s *StoreSQL) OpenMessage(from string, helo string, recipient string, ipAdd
 	} else {
 		_ = copy(ip6, ipAddress.IP)
 	}
-	r, err := s.statements["insertEmail"].Exec(from, helo, recipient, ip4, ip6, returnPath, isTLS, transport)
+	r, err := s.statements["insertEmail"].Exec(from, helo, recipient, ip4, ip6, returnPath, transport, protocol)
 	if err != nil {
 		return 0, err
 	}
@@ -174,12 +183,18 @@ func (s *StoreSQL) AddChunk(data []byte, hash []byte) error {
 }
 
 // CloseMessage implements the Storage interface
-func (s *StoreSQL) CloseMessage(mailID uint64, size int64, partsInfo *PartsInfo, subject string, deliveryID string, to string, from string) error {
+func (s *StoreSQL) CloseMessage(
+	mailID uint64,
+	size int64,
+	partsInfo *PartsInfo,
+	subject string,
+	queuedID string,
+	to string, from string) error {
 	partsInfoJson, err := json.Marshal(partsInfo)
 	if err != nil {
 		return err
 	}
-	_, err = s.statements["finalizeEmail"].Exec(size, partsInfoJson, subject, deliveryID, to, mailID)
+	_, err = s.statements["finalizeEmail"].Exec(size, partsInfoJson, subject, queuedID, to, mailID)
 	if err != nil {
 		return err
 	}

mail/envelope.go

@@ -277,6 +277,47 @@ func (e *Envelope) PopRcpt() Address {
 	return ret
 }
 
+func (e *Envelope) Protocol() Protocol {
+	protocol := ProtocolSMTP
+	switch {
+	case !e.ESMTP && !e.TLS:
+		protocol = ProtocolSMTP
+	case !e.ESMTP && e.TLS:
+		protocol = ProtocolSMTPS
+	case e.ESMTP && !e.TLS:
+		protocol = ProtocolESMTP
+	case e.ESMTP && e.TLS:
+		protocol = ProtocolESMTPS
+	}
+	return protocol
+}
+
+type Protocol int
+
+const (
+	ProtocolSMTP Protocol = iota
+	ProtocolSMTPS
+	ProtocolESMTP
+	ProtocolESMTPS
+	ProtocolLTPS
+)
+
+func (p Protocol) String() string {
+	switch p {
+	case ProtocolSMTP:
+		return "SMTP"
+	case ProtocolSMTPS:
+		return "SMTPS"
+	case ProtocolESMTP:
+		return "ESMTP"
+	case ProtocolESMTPS:
+		return "ESMTPS"
+	case ProtocolLTPS:
+		return "LTPS"
+	}
+	return "unknown"
+}
+
 const (
 	statePlainText = iota
 	stateStartEncodedWord

mail/smtp/parse.go

@@ -24,6 +24,7 @@ const (
 
 type PathParam []string
 
+// A TransportType specifies the message transport according to https://tools.ietf.org/html/rfc6152
 type TransportType int
 
 const (
@@ -33,6 +34,20 @@ const (
 	TransportTypeInvalid
 )
 
+func (t TransportType) String() string {
+	switch t {
+	case TransportType7bit:
+		return "7bit"
+	case TransportType8bit:
+		return "8bit"
+	case TransportTypeUnspecified:
+		return "unknown"
+	case TransportTypeInvalid:
+		return "invalid"
+	}
+	return "invalid"
+}
+
 // is8BitMime checks for the BODY parameter as
 func (p PathParam) Transport() TransportType {
 	if len(p) != 2 {