Mirrors/go-inbucket
1
0
Fork 0
mirror of https://github.com/jhillyerd/inbucket.git synced 2025-12-17 17:47:03 +00:00
Code Issues Releases Wiki Activity

pop3, smtp: rename Session method receivers to s

Browse Source
This commit is contained in:
James Hillyerd
2018-03-27 20:44:17 -07:00
parent e2ba10c8ca
commit 6f25a1320e
2 changed files with 355 additions and 355 deletions
Download Patch File Download Diff File Expand all files Collapse all files

416
pkg/server/pop3/handler.go
View File

@@ -78,8 +78,8 @@ func NewSession(server *Server, id int, conn net.Conn) *Session {
reader: reader, remoteHost: host} reader: reader, remoteHost: host}
} }
func (ses *Session) String() string { func (s *Session) String() string {
return fmt.Sprintf("Session{id: %v, state: %v}", ses.id, ses.state) return fmt.Sprintf("Session{id: %v, state: %v}", s.id, s.state)
} }
/* Session flow: /* Session flow:
@@ -100,23 +100,23 @@ func (s *Server) startSession(id int, conn net.Conn) {
//expConnectsCurrent.Add(-1) //expConnectsCurrent.Add(-1)
}() }()
ses := NewSession(s, id, conn) ssn := NewSession(s, id, conn)
ses.send(fmt.Sprintf("+OK Inbucket POP3 server ready <%v.%v@%v>", os.Getpid(), ssn.send(fmt.Sprintf("+OK Inbucket POP3 server ready <%v.%v@%v>", os.Getpid(),
time.Now().Unix(), s.domain)) time.Now().Unix(), s.domain))
// This is our command reading loop // This is our command reading loop
for ses.state != QUIT && ses.sendError == nil { for ssn.state != QUIT && ssn.sendError == nil {
line, err := ses.readLine() line, err := ssn.readLine()
if err == nil { if err == nil {
if cmd, arg, ok := ses.parseCmd(line); ok { if cmd, arg, ok := ssn.parseCmd(line); ok {
// Check against valid SMTP commands // Check against valid SMTP commands
if cmd == "" { if cmd == "" {
ses.send("-ERR Speak up") ssn.send("-ERR Speak up")
continue continue
} }
if !commands[cmd] { if !commands[cmd] {
ses.send(fmt.Sprintf("-ERR Syntax error, %v command unrecognized", cmd)) ssn.send(fmt.Sprintf("-ERR Syntax error, %v command unrecognized", cmd))
ses.logWarn("Unrecognized command: %v", cmd) ssn.logWarn("Unrecognized command: %v", cmd)
continue continue
} }
@@ -124,307 +124,307 @@ func (s *Server) startSession(id int, conn net.Conn) {
switch cmd { switch cmd {
case "CAPA": case "CAPA":
// List our capabilities per RFC2449 // List our capabilities per RFC2449
ses.send("+OK Capability list follows") ssn.send("+OK Capability list follows")
ses.send("TOP") ssn.send("TOP")
ses.send("USER") ssn.send("USER")
ses.send("UIDL") ssn.send("UIDL")
ses.send("IMPLEMENTATION Inbucket") ssn.send("IMPLEMENTATION Inbucket")
ses.send(".") ssn.send(".")
continue continue
} }
// Send command to handler for current state // Send command to handler for current state
switch ses.state { switch ssn.state {
case AUTHORIZATION: case AUTHORIZATION:
ses.authorizationHandler(cmd, arg) ssn.authorizationHandler(cmd, arg)
continue continue
case TRANSACTION: case TRANSACTION:
ses.transactionHandler(cmd, arg) ssn.transactionHandler(cmd, arg)
continue continue
} }
ses.logError("Session entered unexpected state %v", ses.state) ssn.logError("Session entered unexpected state %v", ssn.state)
break break
} else { } else {
ses.send("-ERR Syntax error, command garbled") ssn.send("-ERR Syntax error, command garbled")
} }
} else { } else {
// readLine() returned an error // readLine() returned an error
if err == io.EOF { if err == io.EOF {
switch ses.state { switch ssn.state {
case AUTHORIZATION: case AUTHORIZATION:
// EOF is common here // EOF is common here
ses.logInfo("Client closed connection (state %v)", ses.state) ssn.logInfo("Client closed connection (state %v)", ssn.state)
default: default:
ses.logWarn("Got EOF while in state %v", ses.state) ssn.logWarn("Got EOF while in state %v", ssn.state)
} }
break break
} }
// not an EOF // not an EOF
ses.logWarn("Connection error: %v", err) ssn.logWarn("Connection error: %v", err)
if netErr, ok := err.(net.Error); ok { if netErr, ok := err.(net.Error); ok {
if netErr.Timeout() { if netErr.Timeout() {
ses.send("-ERR Idle timeout, bye bye") ssn.send("-ERR Idle timeout, bye bye")
break break
} }
} }
ses.send("-ERR Connection error, sorry") ssn.send("-ERR Connection error, sorry")
break break
} }
} }
if ses.sendError != nil { if ssn.sendError != nil {
ses.logWarn("Network send error: %v", ses.sendError) ssn.logWarn("Network send error: %v", ssn.sendError)
} }
ses.logInfo("Closing connection") ssn.logInfo("Closing connection")
} }
// AUTHORIZATION state // AUTHORIZATION state
func (ses *Session) authorizationHandler(cmd string, args []string) { func (s *Session) authorizationHandler(cmd string, args []string) {
switch cmd { switch cmd {
case "QUIT": case "QUIT":
ses.send("+OK Goodnight and good luck") s.send("+OK Goodnight and good luck")
ses.enterState(QUIT) s.enterState(QUIT)
case "USER": case "USER":
if len(args) > 0 { if len(args) > 0 {
ses.user = args[0] s.user = args[0]
ses.send(fmt.Sprintf("+OK Hello %v, welcome to Inbucket", ses.user)) s.send(fmt.Sprintf("+OK Hello %v, welcome to Inbucket", s.user))
} else { } else {
ses.send("-ERR Missing username argument") s.send("-ERR Missing username argument")
} }
case "PASS": case "PASS":
if ses.user == "" { if s.user == "" {
ses.ooSeq(cmd) s.ooSeq(cmd)
} else { } else {
ses.loadMailbox() s.loadMailbox()
ses.send(fmt.Sprintf("+OK Found %v messages for %v", ses.msgCount, ses.user)) s.send(fmt.Sprintf("+OK Found %v messages for %v", s.msgCount, s.user))
ses.enterState(TRANSACTION) s.enterState(TRANSACTION)
} }
case "APOP": case "APOP":
if len(args) != 2 { if len(args) != 2 {
ses.logWarn("Expected two arguments for APOP") s.logWarn("Expected two arguments for APOP")
ses.send("-ERR APOP requires two arguments") s.send("-ERR APOP requires two arguments")
return return
} }
ses.user = args[0] s.user = args[0]
ses.loadMailbox() s.loadMailbox()
ses.send(fmt.Sprintf("+OK Found %v messages for %v", ses.msgCount, ses.user)) s.send(fmt.Sprintf("+OK Found %v messages for %v", s.msgCount, s.user))
ses.enterState(TRANSACTION) s.enterState(TRANSACTION)
default: default:
ses.ooSeq(cmd) s.ooSeq(cmd)
} }
} }
// TRANSACTION state // TRANSACTION state
func (ses *Session) transactionHandler(cmd string, args []string) { func (s *Session) transactionHandler(cmd string, args []string) {
switch cmd { switch cmd {
case "STAT": case "STAT":
if len(args) != 0 { if len(args) != 0 {
ses.logWarn("STAT got an unexpected argument") s.logWarn("STAT got an unexpected argument")
ses.send("-ERR STAT command must have no arguments") s.send("-ERR STAT command must have no arguments")
return return
} }
var count int var count int
var size int64 var size int64
for i, msg := range ses.messages { for i, msg := range s.messages {
if ses.retain[i] { if s.retain[i] {
count++ count++
size += msg.Size() size += msg.Size()
} }
} }
ses.send(fmt.Sprintf("+OK %v %v", count, size)) s.send(fmt.Sprintf("+OK %v %v", count, size))
case "LIST": case "LIST":
if len(args) > 1 { if len(args) > 1 {
ses.logWarn("LIST command had more than 1 argument") s.logWarn("LIST command had more than 1 argument")
ses.send("-ERR LIST command must have zero or one argument") s.send("-ERR LIST command must have zero or one argument")
return return
} }
if len(args) == 1 { if len(args) == 1 {
msgNum, err := strconv.ParseInt(args[0], 10, 32) msgNum, err := strconv.ParseInt(args[0], 10, 32)
if err != nil { if err != nil {
ses.logWarn("LIST command argument was not an integer") s.logWarn("LIST command argument was not an integer")
ses.send("-ERR LIST command requires an integer argument") s.send("-ERR LIST command requires an integer argument")
return return
} }
if msgNum < 1 { if msgNum < 1 {
ses.logWarn("LIST command argument was less than 1") s.logWarn("LIST command argument was less than 1")
ses.send("-ERR LIST argument must be greater than 0") s.send("-ERR LIST argument must be greater than 0")
return return
} }
if int(msgNum) > len(ses.messages) { if int(msgNum) > len(s.messages) {
ses.logWarn("LIST command argument was greater than number of messages") s.logWarn("LIST command argument was greater than number of messages")
ses.send("-ERR LIST argument must not exceed the number of messages") s.send("-ERR LIST argument must not exceed the number of messages")
return return
} }
if !ses.retain[msgNum-1] { if !s.retain[msgNum-1] {
ses.logWarn("Client tried to LIST a message it had deleted") s.logWarn("Client tried to LIST a message it had deleted")
ses.send(fmt.Sprintf("-ERR You deleted message %v", msgNum)) s.send(fmt.Sprintf("-ERR You deleted message %v", msgNum))
return return
} }
ses.send(fmt.Sprintf("+OK %v %v", msgNum, ses.messages[msgNum-1].Size())) s.send(fmt.Sprintf("+OK %v %v", msgNum, s.messages[msgNum-1].Size()))
} else { } else {
ses.send(fmt.Sprintf("+OK Listing %v messages", ses.msgCount)) s.send(fmt.Sprintf("+OK Listing %v messages", s.msgCount))
for i, msg := range ses.messages { for i, msg := range s.messages {
if ses.retain[i] { if s.retain[i] {
ses.send(fmt.Sprintf("%v %v", i+1, msg.Size())) s.send(fmt.Sprintf("%v %v", i+1, msg.Size()))
} }
} }
ses.send(".") s.send(".")
} }
case "UIDL": case "UIDL":
if len(args) > 1 { if len(args) > 1 {
ses.logWarn("UIDL command had more than 1 argument") s.logWarn("UIDL command had more than 1 argument")
ses.send("-ERR UIDL command must have zero or one argument") s.send("-ERR UIDL command must have zero or one argument")
return return
} }
if len(args) == 1 { if len(args) == 1 {
msgNum, err := strconv.ParseInt(args[0], 10, 32) msgNum, err := strconv.ParseInt(args[0], 10, 32)
if err != nil { if err != nil {
ses.logWarn("UIDL command argument was not an integer") s.logWarn("UIDL command argument was not an integer")
ses.send("-ERR UIDL command requires an integer argument") s.send("-ERR UIDL command requires an integer argument")
return return
} }
if msgNum < 1 { if msgNum < 1 {
ses.logWarn("UIDL command argument was less than 1") s.logWarn("UIDL command argument was less than 1")
ses.send("-ERR UIDL argument must be greater than 0") s.send("-ERR UIDL argument must be greater than 0")
return return
} }
if int(msgNum) > len(ses.messages) { if int(msgNum) > len(s.messages) {
ses.logWarn("UIDL command argument was greater than number of messages") s.logWarn("UIDL command argument was greater than number of messages")
ses.send("-ERR UIDL argument must not exceed the number of messages") s.send("-ERR UIDL argument must not exceed the number of messages")
return return
} }
if !ses.retain[msgNum-1] { if !s.retain[msgNum-1] {
ses.logWarn("Client tried to UIDL a message it had deleted") s.logWarn("Client tried to UIDL a message it had deleted")
ses.send(fmt.Sprintf("-ERR You deleted message %v", msgNum)) s.send(fmt.Sprintf("-ERR You deleted message %v", msgNum))
return return
} }
ses.send(fmt.Sprintf("+OK %v %v", msgNum, ses.messages[msgNum-1].ID())) s.send(fmt.Sprintf("+OK %v %v", msgNum, s.messages[msgNum-1].ID()))
} else { } else {
ses.send(fmt.Sprintf("+OK Listing %v messages", ses.msgCount)) s.send(fmt.Sprintf("+OK Listing %v messages", s.msgCount))
for i, msg := range ses.messages { for i, msg := range s.messages {
if ses.retain[i] { if s.retain[i] {
ses.send(fmt.Sprintf("%v %v", i+1, msg.ID())) s.send(fmt.Sprintf("%v %v", i+1, msg.ID()))
} }
} }
ses.send(".") s.send(".")
} }
case "DELE": case "DELE":
if len(args) != 1 { if len(args) != 1 {
ses.logWarn("DELE command had invalid number of arguments") s.logWarn("DELE command had invalid number of arguments")
ses.send("-ERR DELE command requires a single argument") s.send("-ERR DELE command requires a single argument")
return return
} }
msgNum, err := strconv.ParseInt(args[0], 10, 32) msgNum, err := strconv.ParseInt(args[0], 10, 32)
if err != nil { if err != nil {
ses.logWarn("DELE command argument was not an integer") s.logWarn("DELE command argument was not an integer")
ses.send("-ERR DELE command requires an integer argument") s.send("-ERR DELE command requires an integer argument")
return return
} }
if msgNum < 1 { if msgNum < 1 {
ses.logWarn("DELE command argument was less than 1") s.logWarn("DELE command argument was less than 1")
ses.send("-ERR DELE argument must be greater than 0") s.send("-ERR DELE argument must be greater than 0")
return return
} }
if int(msgNum) > len(ses.messages) { if int(msgNum) > len(s.messages) {
ses.logWarn("DELE command argument was greater than number of messages") s.logWarn("DELE command argument was greater than number of messages")
ses.send("-ERR DELE argument must not exceed the number of messages") s.send("-ERR DELE argument must not exceed the number of messages")
return return
} }
if ses.retain[msgNum-1] { if s.retain[msgNum-1] {
ses.retain[msgNum-1] = false s.retain[msgNum-1] = false
ses.msgCount-- s.msgCount--
ses.send(fmt.Sprintf("+OK Deleted message %v", msgNum)) s.send(fmt.Sprintf("+OK Deleted message %v", msgNum))
} else { } else {
ses.logWarn("Client tried to DELE an already deleted message") s.logWarn("Client tried to DELE an already deleted message")
ses.send(fmt.Sprintf("-ERR Message %v has already been deleted", msgNum)) s.send(fmt.Sprintf("-ERR Message %v has already been deleted", msgNum))
} }
case "RETR": case "RETR":
if len(args) != 1 { if len(args) != 1 {
ses.logWarn("RETR command had invalid number of arguments") s.logWarn("RETR command had invalid number of arguments")
ses.send("-ERR RETR command requires a single argument") s.send("-ERR RETR command requires a single argument")
return return
} }
msgNum, err := strconv.ParseInt(args[0], 10, 32) msgNum, err := strconv.ParseInt(args[0], 10, 32)
if err != nil { if err != nil {
ses.logWarn("RETR command argument was not an integer") s.logWarn("RETR command argument was not an integer")
ses.send("-ERR RETR command requires an integer argument") s.send("-ERR RETR command requires an integer argument")
return return
} }
if msgNum < 1 { if msgNum < 1 {
ses.logWarn("RETR command argument was less than 1") s.logWarn("RETR command argument was less than 1")
ses.send("-ERR RETR argument must be greater than 0") s.send("-ERR RETR argument must be greater than 0")
return return
} }
if int(msgNum) > len(ses.messages) { if int(msgNum) > len(s.messages) {
ses.logWarn("RETR command argument was greater than number of messages") s.logWarn("RETR command argument was greater than number of messages")
ses.send("-ERR RETR argument must not exceed the number of messages") s.send("-ERR RETR argument must not exceed the number of messages")
return return
} }
ses.send(fmt.Sprintf("+OK %v bytes follows", ses.messages[msgNum-1].Size())) s.send(fmt.Sprintf("+OK %v bytes follows", s.messages[msgNum-1].Size()))
ses.sendMessage(ses.messages[msgNum-1]) s.sendMessage(s.messages[msgNum-1])
case "TOP": case "TOP":
if len(args) != 2 { if len(args) != 2 {
ses.logWarn("TOP command had invalid number of arguments") s.logWarn("TOP command had invalid number of arguments")
ses.send("-ERR TOP command requires two arguments") s.send("-ERR TOP command requires two arguments")
return return
} }
msgNum, err := strconv.ParseInt(args[0], 10, 32) msgNum, err := strconv.ParseInt(args[0], 10, 32)
if err != nil { if err != nil {
ses.logWarn("TOP command first argument was not an integer") s.logWarn("TOP command first argument was not an integer")
ses.send("-ERR TOP command requires an integer argument") s.send("-ERR TOP command requires an integer argument")
return return
} }
if msgNum < 1 { if msgNum < 1 {
ses.logWarn("TOP command first argument was less than 1") s.logWarn("TOP command first argument was less than 1")
ses.send("-ERR TOP first argument must be greater than 0") s.send("-ERR TOP first argument must be greater than 0")
return return
} }
if int(msgNum) > len(ses.messages) { if int(msgNum) > len(s.messages) {
ses.logWarn("TOP command first argument was greater than number of messages") s.logWarn("TOP command first argument was greater than number of messages")
ses.send("-ERR TOP first argument must not exceed the number of messages") s.send("-ERR TOP first argument must not exceed the number of messages")
return return
} }
var lines int64 var lines int64
lines, err = strconv.ParseInt(args[1], 10, 32) lines, err = strconv.ParseInt(args[1], 10, 32)
if err != nil { if err != nil {
ses.logWarn("TOP command second argument was not an integer") s.logWarn("TOP command second argument was not an integer")
ses.send("-ERR TOP command requires an integer argument") s.send("-ERR TOP command requires an integer argument")
return return
} }
if lines < 0 { if lines < 0 {
ses.logWarn("TOP command second argument was negative") s.logWarn("TOP command second argument was negative")
ses.send("-ERR TOP second argument must be non-negative") s.send("-ERR TOP second argument must be non-negative")
return return
} }
ses.send("+OK Top of message follows") s.send("+OK Top of message follows")
ses.sendMessageTop(ses.messages[msgNum-1], int(lines)) s.sendMessageTop(s.messages[msgNum-1], int(lines))
case "QUIT": case "QUIT":
ses.send("+OK We will process your deletes") s.send("+OK We will process your deletes")
ses.processDeletes() s.processDeletes()
ses.enterState(QUIT) s.enterState(QUIT)
case "NOOP": case "NOOP":
ses.send("+OK I have sucessfully done nothing") s.send("+OK I have sucessfully done nothing")
case "RSET": case "RSET":
// Reset session, don't actually delete anything I told you to // Reset session, don't actually delete anything I told you to
ses.logTrace("Resetting session state on RSET request") s.logTrace("Resetting session state on RSET request")
ses.reset() s.reset()
ses.send("+OK Session reset") s.send("+OK Session reset")
default: default:
ses.ooSeq(cmd) s.ooSeq(cmd)
} }
} }
// Send the contents of the message to the client // Send the contents of the message to the client
func (ses *Session) sendMessage(msg storage.Message) { func (s *Session) sendMessage(msg storage.Message) {
reader, err := msg.Source() reader, err := msg.Source()
if err != nil { if err != nil {
ses.logError("Failed to read message for RETR command") s.logError("Failed to read message for RETR command")
ses.send("-ERR Failed to RETR that message, internal error") s.send("-ERR Failed to RETR that message, internal error")
return return
} }
defer func() { defer func() {
if err := reader.Close(); err != nil { if err := reader.Close(); err != nil {
ses.logError("Failed to close message: %v", err) s.logError("Failed to close message: %v", err)
} }
}() }()
@@ -435,29 +435,29 @@ func (ses *Session) sendMessage(msg storage.Message) {
if strings.HasPrefix(line, ".") { if strings.HasPrefix(line, ".") {
line = "." + line line = "." + line
} }
ses.send(line) s.send(line)
} }
if err = scanner.Err(); err != nil { if err = scanner.Err(); err != nil {
ses.logError("Failed to read message for RETR command") s.logError("Failed to read message for RETR command")
ses.send(".") s.send(".")
ses.send("-ERR Failed to RETR that message, internal error") s.send("-ERR Failed to RETR that message, internal error")
return return
} }
ses.send(".") s.send(".")
} }
// Send the headers plus the top N lines to the client // Send the headers plus the top N lines to the client
func (ses *Session) sendMessageTop(msg storage.Message, lineCount int) { func (s *Session) sendMessageTop(msg storage.Message, lineCount int) {
reader, err := msg.Source() reader, err := msg.Source()
if err != nil { if err != nil {
ses.logError("Failed to read message for RETR command") s.logError("Failed to read message for RETR command")
ses.send("-ERR Failed to RETR that message, internal error") s.send("-ERR Failed to RETR that message, internal error")
return return
} }
defer func() { defer func() {
if err := reader.Close(); err != nil { if err := reader.Close(); err != nil {
ses.logError("Failed to close message: %v", err) s.logError("Failed to close message: %v", err)
} }
}() }()
@@ -482,85 +482,85 @@ func (ses *Session) sendMessageTop(msg storage.Message, lineCount int) {
inBody = true inBody = true
} }
} }
ses.send(line) s.send(line)
} }
if err = scanner.Err(); err != nil { if err = scanner.Err(); err != nil {
ses.logError("Failed to read message for RETR command") s.logError("Failed to read message for RETR command")
ses.send(".") s.send(".")
ses.send("-ERR Failed to RETR that message, internal error") s.send("-ERR Failed to RETR that message, internal error")
return return
} }
ses.send(".") s.send(".")
} }
// Load the users mailbox // Load the users mailbox
func (ses *Session) loadMailbox() { func (s *Session) loadMailbox() {
m, err := ses.server.store.GetMessages(ses.user) m, err := s.server.store.GetMessages(s.user)
if err != nil { if err != nil {
ses.logError("Failed to load messages for %v: %v", ses.user, err) s.logError("Failed to load messages for %v: %v", s.user, err)
} }
ses.messages = m s.messages = m
ses.retainAll() s.retainAll()
} }
// Reset retain flag to true for all messages // Reset retain flag to true for all messages
func (ses *Session) retainAll() { func (s *Session) retainAll() {
ses.retain = make([]bool, len(ses.messages)) s.retain = make([]bool, len(s.messages))
for i := range ses.retain { for i := range s.retain {
ses.retain[i] = true s.retain[i] = true
} }
ses.msgCount = len(ses.messages) s.msgCount = len(s.messages)
} }
// This would be considered the "UPDATE" state in the RFC, but it does not fit // This would be considered the "UPDATE" state in the RFC, but it does not fit
// with our state-machine design here, since no commands are accepted - it just // with our state-machine design here, since no commands are accepted - it just
// indicates that the session was closed cleanly and that deletes should be // indicates that the session was closed cleanly and that deletes should be
// processed. // processed.
func (ses *Session) processDeletes() { func (s *Session) processDeletes() {
ses.logInfo("Processing deletes") s.logInfo("Processing deletes")
for i, msg := range ses.messages { for i, msg := range s.messages {
if !ses.retain[i] { if !s.retain[i] {
ses.logTrace("Deleting %v", msg) s.logTrace("Deleting %v", msg)
if err := ses.server.store.RemoveMessage(ses.user, msg.ID()); err != nil { if err := s.server.store.RemoveMessage(s.user, msg.ID()); err != nil {
ses.logWarn("Error deleting %v: %v", msg, err) s.logWarn("Error deleting %v: %v", msg, err)
} }
} }
} }
} }
func (ses *Session) enterState(state State) { func (s *Session) enterState(state State) {
ses.state = state s.state = state
ses.logTrace("Entering state %v", state) s.logTrace("Entering state %v", state)
} }
// Calculate the next read or write deadline based on maxIdleSeconds // Calculate the next read or write deadline based on maxIdleSeconds
func (ses *Session) nextDeadline() time.Time { func (s *Session) nextDeadline() time.Time {
return time.Now().Add(ses.server.timeout) return time.Now().Add(s.server.timeout)
} }
// Send requested message, store errors in Session.sendError // Send requested message, store errors in Session.sendError
func (ses *Session) send(msg string) { func (s *Session) send(msg string) {
if err := ses.conn.SetWriteDeadline(ses.nextDeadline()); err != nil { if err := s.conn.SetWriteDeadline(s.nextDeadline()); err != nil {
ses.sendError = err s.sendError = err
return return
} }
if _, err := fmt.Fprint(ses.conn, msg+"\r\n"); err != nil { if _, err := fmt.Fprint(s.conn, msg+"\r\n"); err != nil {
ses.sendError = err s.sendError = err
ses.logWarn("Failed to send: '%v'", msg) s.logWarn("Failed to send: '%v'", msg)
return return
} }
ses.logTrace(">> %v >>", msg) s.logTrace(">> %v >>", msg)
} }
// readByteLine reads a line of input into the provided buffer. Does // readByteLine reads a line of input into the provided buffer. Does
// not reset the Buffer - please do so prior to calling. // not reset the Buffer - please do so prior to calling.
func (ses *Session) readByteLine(buf *bytes.Buffer) error { func (s *Session) readByteLine(buf *bytes.Buffer) error {
if err := ses.conn.SetReadDeadline(ses.nextDeadline()); err != nil { if err := s.conn.SetReadDeadline(s.nextDeadline()); err != nil {
return err return err
} }
for { for {
line, err := ses.reader.ReadBytes('\r') line, err := s.reader.ReadBytes('\r')
if err != nil { if err != nil {
return err return err
} }
@@ -568,7 +568,7 @@ func (ses *Session) readByteLine(buf *bytes.Buffer) error {
return err return err
} }
// Read the next byte looking for '\n' // Read the next byte looking for '\n'
c, err := ses.reader.ReadByte() c, err := s.reader.ReadByte()
if err != nil { if err != nil {
return err return err
} }
@@ -585,19 +585,19 @@ func (ses *Session) readByteLine(buf *bytes.Buffer) error {
} }
// Reads a line of input // Reads a line of input
func (ses *Session) readLine() (line string, err error) { func (s *Session) readLine() (line string, err error) {
if err = ses.conn.SetReadDeadline(ses.nextDeadline()); err != nil { if err = s.conn.SetReadDeadline(s.nextDeadline()); err != nil {
return "", err return "", err
} }
line, err = ses.reader.ReadString('\n') line, err = s.reader.ReadString('\n')
if err != nil { if err != nil {
return "", err return "", err
} }
ses.logTrace("<< %v <<", strings.TrimRight(line, "\r\n")) s.logTrace("<< %v <<", strings.TrimRight(line, "\r\n"))
return line, nil return line, nil
} }
func (ses *Session) parseCmd(line string) (cmd string, args []string, ok bool) { func (s *Session) parseCmd(line string) (cmd string, args []string, ok bool) {
line = strings.TrimRight(line, "\r\n") line = strings.TrimRight(line, "\r\n")
if line == "" { if line == "" {
return "", nil, true return "", nil, true
@@ -607,32 +607,32 @@ func (ses *Session) parseCmd(line string) (cmd string, args []string, ok bool) {
return strings.ToUpper(words[0]), words[1:], true return strings.ToUpper(words[0]), words[1:], true
} }
func (ses *Session) reset() { func (s *Session) reset() {
ses.retainAll() s.retainAll()
} }
func (ses *Session) ooSeq(cmd string) { func (s *Session) ooSeq(cmd string) {
ses.send(fmt.Sprintf("-ERR Command %v is out of sequence", cmd)) s.send(fmt.Sprintf("-ERR Command %v is out of sequence", cmd))
ses.logWarn("Wasn't expecting %v here", cmd) s.logWarn("Wasn't expecting %v here", cmd)
} }
// Session specific logging methods // Session specific logging methods
func (ses *Session) logTrace(msg string, args ...interface{}) { func (s *Session) logTrace(msg string, args ...interface{}) {
log.Tracef("POP3[%v]<%v> %v", ses.remoteHost, ses.id, fmt.Sprintf(msg, args...)) log.Tracef("POP3[%v]<%v> %v", s.remoteHost, s.id, fmt.Sprintf(msg, args...))
} }
func (ses *Session) logInfo(msg string, args ...interface{}) { func (s *Session) logInfo(msg string, args ...interface{}) {
log.Infof("POP3[%v]<%v> %v", ses.remoteHost, ses.id, fmt.Sprintf(msg, args...)) log.Infof("POP3[%v]<%v> %v", s.remoteHost, s.id, fmt.Sprintf(msg, args...))
} }
func (ses *Session) logWarn(msg string, args ...interface{}) { func (s *Session) logWarn(msg string, args ...interface{}) {
// Update metrics // Update metrics
//expWarnsTotal.Add(1) //expWarnsTotal.Add(1)
log.Warnf("POP3[%v]<%v> %v", ses.remoteHost, ses.id, fmt.Sprintf(msg, args...)) log.Warnf("POP3[%v]<%v> %v", s.remoteHost, s.id, fmt.Sprintf(msg, args...))
} }
func (ses *Session) logError(msg string, args ...interface{}) { func (s *Session) logError(msg string, args ...interface{}) {
// Update metrics // Update metrics
//expErrorsTotal.Add(1) //expErrorsTotal.Add(1)
log.Errorf("POP3[%v]<%v> %v", ses.remoteHost, ses.id, fmt.Sprintf(msg, args...)) log.Errorf("POP3[%v]<%v> %v", s.remoteHost, s.id, fmt.Sprintf(msg, args...))
} }

294
pkg/server/smtp/handler.go
View File

@@ -96,8 +96,8 @@ func NewSession(server *Server, id int, conn net.Conn) *Session {
} }
} }
func (ss *Session) String() string { func (s *Session) String() string {
return fmt.Sprintf("Session{id: %v, state: %v}", ss.id, ss.state) return fmt.Sprintf("Session{id: %v, state: %v}", s.id, s.state)
} }
/* Session flow: /* Session flow:
@@ -118,27 +118,27 @@ func (s *Server) startSession(id int, conn net.Conn) {
expConnectsCurrent.Add(-1) expConnectsCurrent.Add(-1)
}() }()
ss := NewSession(s, id, conn) ssn := NewSession(s, id, conn)
ss.greet() ssn.greet()
// This is our command reading loop // This is our command reading loop
for ss.state != QUIT && ss.sendError == nil { for ssn.state != QUIT && ssn.sendError == nil {
if ss.state == DATA { if ssn.state == DATA {
// Special case, does not use SMTP command format // Special case, does not use SMTP command format
ss.dataHandler() ssn.dataHandler()
continue continue
} }
line, err := ss.readLine() line, err := ssn.readLine()
if err == nil { if err == nil {
if cmd, arg, ok := ss.parseCmd(line); ok { if cmd, arg, ok := ssn.parseCmd(line); ok {
// Check against valid SMTP commands // Check against valid SMTP commands
if cmd == "" { if cmd == "" {
ss.send("500 Speak up") ssn.send("500 Speak up")
continue continue
} }
if !commands[cmd] { if !commands[cmd] {
ss.send(fmt.Sprintf("500 Syntax error, %v command unrecognized", cmd)) ssn.send(fmt.Sprintf("500 Syntax error, %v command unrecognized", cmd))
ss.logWarn("Unrecognized command: %v", cmd) ssn.logWarn("Unrecognized command: %v", cmd)
continue continue
} }
@@ -146,99 +146,99 @@ func (s *Server) startSession(id int, conn net.Conn) {
switch cmd { switch cmd {
case "SEND", "SOML", "SAML", "EXPN", "HELP", "TURN": case "SEND", "SOML", "SAML", "EXPN", "HELP", "TURN":
// These commands are not implemented in any state // These commands are not implemented in any state
ss.send(fmt.Sprintf("502 %v command not implemented", cmd)) ssn.send(fmt.Sprintf("502 %v command not implemented", cmd))
ss.logWarn("Command %v not implemented by Inbucket", cmd) ssn.logWarn("Command %v not implemented by Inbucket", cmd)
continue continue
case "VRFY": case "VRFY":
ss.send("252 Cannot VRFY user, but will accept message") ssn.send("252 Cannot VRFY user, but will accept message")
continue continue
case "NOOP": case "NOOP":
ss.send("250 I have sucessfully done nothing") ssn.send("250 I have sucessfully done nothing")
continue continue
case "RSET": case "RSET":
// Reset session // Reset session
ss.logTrace("Resetting session state on RSET request") ssn.logTrace("Resetting session state on RSET request")
ss.reset() ssn.reset()
ss.send("250 Session reset") ssn.send("250 Session reset")
continue continue
case "QUIT": case "QUIT":
ss.send("221 Goodnight and good luck") ssn.send("221 Goodnight and good luck")
ss.enterState(QUIT) ssn.enterState(QUIT)
continue continue
} }
// Send command to handler for current state // Send command to handler for current state
switch ss.state { switch ssn.state {
case GREET: case GREET:
ss.greetHandler(cmd, arg) ssn.greetHandler(cmd, arg)
continue continue
case READY: case READY:
ss.readyHandler(cmd, arg) ssn.readyHandler(cmd, arg)
continue continue
case MAIL: case MAIL:
ss.mailHandler(cmd, arg) ssn.mailHandler(cmd, arg)
continue continue
} }
ss.logError("Session entered unexpected state %v", ss.state) ssn.logError("Session entered unexpected state %v", ssn.state)
break break
} else { } else {
ss.send("500 Syntax error, command garbled") ssn.send("500 Syntax error, command garbled")
} }
} else { } else {
// readLine() returned an error // readLine() returned an error
if err == io.EOF { if err == io.EOF {
switch ss.state { switch ssn.state {
case GREET, READY: case GREET, READY:
// EOF is common here // EOF is common here
ss.logInfo("Client closed connection (state %v)", ss.state) ssn.logInfo("Client closed connection (state %v)", ssn.state)
default: default:
ss.logWarn("Got EOF while in state %v", ss.state) ssn.logWarn("Got EOF while in state %v", ssn.state)
} }
break break
} }
// not an EOF // not an EOF
ss.logWarn("Connection error: %v", err) ssn.logWarn("Connection error: %v", err)
if netErr, ok := err.(net.Error); ok { if netErr, ok := err.(net.Error); ok {
if netErr.Timeout() { if netErr.Timeout() {
ss.send("221 Idle timeout, bye bye") ssn.send("221 Idle timeout, bye bye")
break break
} }
} }
ss.send("221 Connection error, sorry") ssn.send("221 Connection error, sorry")
break break
} }
} }
if ss.sendError != nil { if ssn.sendError != nil {
ss.logWarn("Network send error: %v", ss.sendError) ssn.logWarn("Network send error: %v", ssn.sendError)
} }
ss.logInfo("Closing connection") ssn.logInfo("Closing connection")
} }
// GREET state -> waiting for HELO // GREET state -> waiting for HELO
func (ss *Session) greetHandler(cmd string, arg string) { func (s *Session) greetHandler(cmd string, arg string) {
switch cmd { switch cmd {
case "HELO": case "HELO":
domain, err := parseHelloArgument(arg) domain, err := parseHelloArgument(arg)
if err != nil { if err != nil {
ss.send("501 Domain/address argument required for HELO") s.send("501 Domain/address argument required for HELO")
return return
} }
ss.remoteDomain = domain s.remoteDomain = domain
ss.send("250 Great, let's get this show on the road") s.send("250 Great, let's get this show on the road")
ss.enterState(READY) s.enterState(READY)
case "EHLO": case "EHLO":
domain, err := parseHelloArgument(arg) domain, err := parseHelloArgument(arg)
if err != nil { if err != nil {
ss.send("501 Domain/address argument required for EHLO") s.send("501 Domain/address argument required for EHLO")
return return
} }
ss.remoteDomain = domain s.remoteDomain = domain
ss.send("250-Great, let's get this show on the road") s.send("250-Great, let's get this show on the road")
ss.send("250-8BITMIME") s.send("250-8BITMIME")
ss.send(fmt.Sprintf("250 SIZE %v", ss.server.maxMessageBytes)) s.send(fmt.Sprintf("250 SIZE %v", s.server.maxMessageBytes))
ss.enterState(READY) s.enterState(READY)
default: default:
ss.ooSeq(cmd) s.ooSeq(cmd)
} }
} }
@@ -254,139 +254,139 @@ func parseHelloArgument(arg string) (string, error) {
} }
// READY state -> waiting for MAIL // READY state -> waiting for MAIL
func (ss *Session) readyHandler(cmd string, arg string) { func (s *Session) readyHandler(cmd string, arg string) {
if cmd == "MAIL" { if cmd == "MAIL" {
// Match FROM, while accepting '>' as quoted pair and in double quoted strings // Match FROM, while accepting '>' as quoted pair and in double quoted strings
// (?i) makes the regex case insensitive, (?:) is non-grouping sub-match // (?i) makes the regex case insensitive, (?:) is non-grouping sub-match
re := regexp.MustCompile("(?i)^FROM:\\s*<((?:\\\\>|[^>])+|\"[^\"]+\"@[^>]+)>( [\\w= ]+)?$") re := regexp.MustCompile("(?i)^FROM:\\s*<((?:\\\\>|[^>])+|\"[^\"]+\"@[^>]+)>( [\\w= ]+)?$")
m := re.FindStringSubmatch(arg) m := re.FindStringSubmatch(arg)
if m == nil { if m == nil {
ss.send("501 Was expecting MAIL arg syntax of FROM:<address>") s.send("501 Was expecting MAIL arg syntax of FROM:<address>")
ss.logWarn("Bad MAIL argument: %q", arg) s.logWarn("Bad MAIL argument: %q", arg)
return return
} }
from := m[1] from := m[1]
if _, _, err := policy.ParseEmailAddress(from); err != nil { if _, _, err := policy.ParseEmailAddress(from); err != nil {
ss.send("501 Bad sender address syntax") s.send("501 Bad sender address syntax")
ss.logWarn("Bad address as MAIL arg: %q, %s", from, err) s.logWarn("Bad address as MAIL arg: %q, %s", from, err)
return return
} }
// This is where the client may put BODY=8BITMIME, but we already // This is where the client may put BODY=8BITMIME, but we already
// read the DATA as bytes, so it does not effect our processing. // read the DATA as bytes, so it does not effect our processing.
if m[2] != "" { if m[2] != "" {
args, ok := ss.parseArgs(m[2]) args, ok := s.parseArgs(m[2])
if !ok { if !ok {
ss.send("501 Unable to parse MAIL ESMTP parameters") s.send("501 Unable to parse MAIL ESMTP parameters")
ss.logWarn("Bad MAIL argument: %q", arg) s.logWarn("Bad MAIL argument: %q", arg)
return return
} }
if args["SIZE"] != "" { if args["SIZE"] != "" {
size, err := strconv.ParseInt(args["SIZE"], 10, 32) size, err := strconv.ParseInt(args["SIZE"], 10, 32)
if err != nil { if err != nil {
ss.send("501 Unable to parse SIZE as an integer") s.send("501 Unable to parse SIZE as an integer")
ss.logWarn("Unable to parse SIZE %q as an integer", args["SIZE"]) s.logWarn("Unable to parse SIZE %q as an integer", args["SIZE"])
return return
} }
if int(size) > ss.server.maxMessageBytes { if int(size) > s.server.maxMessageBytes {
ss.send("552 Max message size exceeded") s.send("552 Max message size exceeded")
ss.logWarn("Client wanted to send oversized message: %v", args["SIZE"]) s.logWarn("Client wanted to send oversized message: %v", args["SIZE"])
return return
} }
} }
} }
ss.from = from s.from = from
ss.logInfo("Mail from: %v", from) s.logInfo("Mail from: %v", from)
ss.send(fmt.Sprintf("250 Roger, accepting mail from <%v>", from)) s.send(fmt.Sprintf("250 Roger, accepting mail from <%v>", from))
ss.enterState(MAIL) s.enterState(MAIL)
} else { } else {
ss.ooSeq(cmd) s.ooSeq(cmd)
} }
} }
// MAIL state -> waiting for RCPTs followed by DATA // MAIL state -> waiting for RCPTs followed by DATA
func (ss *Session) mailHandler(cmd string, arg string) { func (s *Session) mailHandler(cmd string, arg string) {
switch cmd { switch cmd {
case "RCPT": case "RCPT":
if (len(arg) < 4) || (strings.ToUpper(arg[0:3]) != "TO:") { if (len(arg) < 4) || (strings.ToUpper(arg[0:3]) != "TO:") {
ss.send("501 Was expecting RCPT arg syntax of TO:<address>") s.send("501 Was expecting RCPT arg syntax of TO:<address>")
ss.logWarn("Bad RCPT argument: %q", arg) s.logWarn("Bad RCPT argument: %q", arg)
return return
} }
// This trim is probably too forgiving // This trim is probably too forgiving
addr := strings.Trim(arg[3:], "<> ") addr := strings.Trim(arg[3:], "<> ")
recip, err := ss.server.apolicy.NewRecipient(addr) recip, err := s.server.apolicy.NewRecipient(addr)
if err != nil { if err != nil {
ss.send("501 Bad recipient address syntax") s.send("501 Bad recipient address syntax")
ss.logWarn("Bad address as RCPT arg: %q, %s", addr, err) s.logWarn("Bad address as RCPT arg: %q, %s", addr, err)
return return
} }
if len(ss.recipients) >= ss.server.maxRecips { if len(s.recipients) >= s.server.maxRecips {
ss.logWarn("Maximum limit of %v recipients reached", ss.server.maxRecips) s.logWarn("Maximum limit of %v recipients reached", s.server.maxRecips)
ss.send(fmt.Sprintf("552 Maximum limit of %v recipients reached", ss.server.maxRecips)) s.send(fmt.Sprintf("552 Maximum limit of %v recipients reached", s.server.maxRecips))
return return
} }
ss.recipients = append(ss.recipients, recip) s.recipients = append(s.recipients, recip)
ss.logInfo("Recipient: %v", addr) s.logInfo("Recipient: %v", addr)
ss.send(fmt.Sprintf("250 I'll make sure <%v> gets this", addr)) s.send(fmt.Sprintf("250 I'll make sure <%v> gets this", addr))
return return
case "DATA": case "DATA":
if arg != "" { if arg != "" {
ss.send("501 DATA command should not have any arguments") s.send("501 DATA command should not have any arguments")
ss.logWarn("Got unexpected args on DATA: %q", arg) s.logWarn("Got unexpected args on DATA: %q", arg)
return return
} }
if len(ss.recipients) > 0 { if len(s.recipients) > 0 {
// We have recipients, go to accept data // We have recipients, go to accept data
ss.enterState(DATA) s.enterState(DATA)
return return
} }
// DATA out of sequence // DATA out of sequence
ss.ooSeq(cmd) s.ooSeq(cmd)
return return
} }
ss.ooSeq(cmd) s.ooSeq(cmd)
} }
// DATA // DATA
func (ss *Session) dataHandler() { func (s *Session) dataHandler() {
ss.send("354 Start mail input; end with <CRLF>.<CRLF>") s.send("354 Start mail input; end with <CRLF>.<CRLF>")
msgBuf := &bytes.Buffer{} msgBuf := &bytes.Buffer{}
for { for {
lineBuf, err := ss.readByteLine() lineBuf, err := s.readByteLine()
if err != nil { if err != nil {
if netErr, ok := err.(net.Error); ok { if netErr, ok := err.(net.Error); ok {
if netErr.Timeout() { if netErr.Timeout() {
ss.send("221 Idle timeout, bye bye") s.send("221 Idle timeout, bye bye")
} }
} }
ss.logWarn("Error: %v while reading", err) s.logWarn("Error: %v while reading", err)
ss.enterState(QUIT) s.enterState(QUIT)
return return
} }
if bytes.Equal(lineBuf, []byte(".\r\n")) || bytes.Equal(lineBuf, []byte(".\n")) { if bytes.Equal(lineBuf, []byte(".\r\n")) || bytes.Equal(lineBuf, []byte(".\n")) {
// Mail data complete. // Mail data complete.
tstamp := time.Now().Format(timeStampFormat) tstamp := time.Now().Format(timeStampFormat)
for _, recip := range ss.recipients { for _, recip := range s.recipients {
if recip.ShouldStore() { if recip.ShouldStore() {
// Generate Received header. // Generate Received header.
prefix := fmt.Sprintf("Received: from %s ([%s]) by %s\r\n for <%s>; %s\r\n", prefix := fmt.Sprintf("Received: from %s ([%s]) by %s\r\n for <%s>; %s\r\n",
ss.remoteDomain, ss.remoteHost, ss.server.domain, recip.Address.Address, s.remoteDomain, s.remoteHost, s.server.domain, recip.Address.Address,
tstamp) tstamp)
// Deliver message. // Deliver message.
_, err := ss.server.manager.Deliver( _, err := s.server.manager.Deliver(
recip, ss.from, ss.recipients, prefix, msgBuf.Bytes()) recip, s.from, s.recipients, prefix, msgBuf.Bytes())
if err != nil { if err != nil {
ss.logError("delivery for %v: %v", recip.LocalPart, err) s.logError("delivery for %v: %v", recip.LocalPart, err)
ss.send(fmt.Sprintf("451 Failed to store message for %v", recip.LocalPart)) s.send(fmt.Sprintf("451 Failed to store message for %v", recip.LocalPart))
ss.reset() s.reset()
return return
} }
} }
expReceivedTotal.Add(1) expReceivedTotal.Add(1)
} }
ss.send("250 Mail accepted for delivery") s.send("250 Mail accepted for delivery")
ss.logInfo("Message size %v bytes", msgBuf.Len()) s.logInfo("Message size %v bytes", msgBuf.Len())
ss.reset() s.reset()
return return
} }
// RFC: remove leading periods from DATA. // RFC: remove leading periods from DATA.
@@ -394,84 +394,84 @@ func (ss *Session) dataHandler() {
lineBuf = lineBuf[1:] lineBuf = lineBuf[1:]
} }
msgBuf.Write(lineBuf) msgBuf.Write(lineBuf)
if msgBuf.Len() > ss.server.maxMessageBytes { if msgBuf.Len() > s.server.maxMessageBytes {
ss.send("552 Maximum message size exceeded") s.send("552 Maximum message size exceeded")
ss.logWarn("Max message size exceeded while in DATA") s.logWarn("Max message size exceeded while in DATA")
ss.reset() s.reset()
return return
} }
} }
} }
func (ss *Session) enterState(state State) { func (s *Session) enterState(state State) {
ss.state = state s.state = state
ss.logTrace("Entering state %v", state) s.logTrace("Entering state %v", state)
} }
func (ss *Session) greet() { func (s *Session) greet() {
ss.send(fmt.Sprintf("220 %v Inbucket SMTP ready", ss.server.domain)) s.send(fmt.Sprintf("220 %v Inbucket SMTP ready", s.server.domain))
} }
// Calculate the next read or write deadline based on maxIdle // Calculate the next read or write deadline based on maxIdle
func (ss *Session) nextDeadline() time.Time { func (s *Session) nextDeadline() time.Time {
return time.Now().Add(ss.server.timeout) return time.Now().Add(s.server.timeout)
} }
// Send requested message, store errors in Session.sendError // Send requested message, store errors in Session.sendError
func (ss *Session) send(msg string) { func (s *Session) send(msg string) {
if err := ss.conn.SetWriteDeadline(ss.nextDeadline()); err != nil { if err := s.conn.SetWriteDeadline(s.nextDeadline()); err != nil {
ss.sendError = err s.sendError = err
return return
} }
if _, err := fmt.Fprint(ss.conn, msg+"\r\n"); err != nil { if _, err := fmt.Fprint(s.conn, msg+"\r\n"); err != nil {
ss.sendError = err s.sendError = err
ss.logWarn("Failed to send: %q", msg) s.logWarn("Failed to send: %q", msg)
return return
} }
ss.logTrace(">> %v >>", msg) s.logTrace(">> %v >>", msg)
} }
// readByteLine reads a line of input, returns byte slice. // readByteLine reads a line of input, returns byte slice.
func (ss *Session) readByteLine() ([]byte, error) { func (s *Session) readByteLine() ([]byte, error) {
if err := ss.conn.SetReadDeadline(ss.nextDeadline()); err != nil { if err := s.conn.SetReadDeadline(s.nextDeadline()); err != nil {
return nil, err return nil, err
} }
return ss.reader.ReadBytes('\n') return s.reader.ReadBytes('\n')
} }
// Reads a line of input // Reads a line of input
func (ss *Session) readLine() (line string, err error) { func (s *Session) readLine() (line string, err error) {
if err = ss.conn.SetReadDeadline(ss.nextDeadline()); err != nil { if err = s.conn.SetReadDeadline(s.nextDeadline()); err != nil {
return "", err return "", err
} }
line, err = ss.reader.ReadString('\n') line, err = s.reader.ReadString('\n')
if err != nil { if err != nil {
return "", err return "", err
} }
ss.logTrace("<< %v <<", strings.TrimRight(line, "\r\n")) s.logTrace("<< %v <<", strings.TrimRight(line, "\r\n"))
return line, nil return line, nil
} }
func (ss *Session) parseCmd(line string) (cmd string, arg string, ok bool) { func (s *Session) parseCmd(line string) (cmd string, arg string, ok bool) {
line = strings.TrimRight(line, "\r\n") line = strings.TrimRight(line, "\r\n")
l := len(line) l := len(line)
switch { switch {
case l == 0: case l == 0:
return "", "", true return "", "", true
case l < 4: case l < 4:
ss.logWarn("Command too short: %q", line) s.logWarn("Command too short: %q", line)
return "", "", false return "", "", false
case l == 4: case l == 4:
return strings.ToUpper(line), "", true return strings.ToUpper(line), "", true
case l == 5: case l == 5:
// Too long to be only command, too short to have args // Too long to be only command, too short to have args
ss.logWarn("Mangled command: %q", line) s.logWarn("Mangled command: %q", line)
return "", "", false return "", "", false
} }
// If we made it here, command is long enough to have args // If we made it here, command is long enough to have args
if line[4] != ' ' { if line[4] != ' ' {
// There wasn't a space after the command? // There wasn't a space after the command?
ss.logWarn("Mangled command: %q", line) s.logWarn("Mangled command: %q", line)
return "", "", false return "", "", false
} }
// I'm not sure if we should trim the args or not, but we will for now // I'm not sure if we should trim the args or not, but we will for now
@@ -483,49 +483,49 @@ func (ss *Session) parseCmd(line string) (cmd string, arg string, ok bool) {
// string: // string:
// " BODY=8BITMIME SIZE=1024" // " BODY=8BITMIME SIZE=1024"
// The leading space is mandatory. // The leading space is mandatory.
func (ss *Session) parseArgs(arg string) (args map[string]string, ok bool) { func (s *Session) parseArgs(arg string) (args map[string]string, ok bool) {
args = make(map[string]string) args = make(map[string]string)
re := regexp.MustCompile(` (\w+)=(\w+)`) re := regexp.MustCompile(` (\w+)=(\w+)`)
pm := re.FindAllStringSubmatch(arg, -1) pm := re.FindAllStringSubmatch(arg, -1)
if pm == nil { if pm == nil {
ss.logWarn("Failed to parse arg string: %q") s.logWarn("Failed to parse arg string: %q")
return nil, false return nil, false
} }
for _, m := range pm { for _, m := range pm {
args[strings.ToUpper(m[1])] = m[2] args[strings.ToUpper(m[1])] = m[2]
} }
ss.logTrace("ESMTP params: %v", args) s.logTrace("ESMTP params: %v", args)
return args, true return args, true
} }
func (ss *Session) reset() { func (s *Session) reset() {
ss.enterState(READY) s.enterState(READY)
ss.from = "" s.from = ""
ss.recipients = nil s.recipients = nil
} }
func (ss *Session) ooSeq(cmd string) { func (s *Session) ooSeq(cmd string) {
ss.send(fmt.Sprintf("503 Command %v is out of sequence", cmd)) s.send(fmt.Sprintf("503 Command %v is out of sequence", cmd))
ss.logWarn("Wasn't expecting %v here", cmd) s.logWarn("Wasn't expecting %v here", cmd)
} }
// Session specific logging methods // Session specific logging methods
func (ss *Session) logTrace(msg string, args ...interface{}) { func (s *Session) logTrace(msg string, args ...interface{}) {
log.Tracef("SMTP[%v]<%v> %v", ss.remoteHost, ss.id, fmt.Sprintf(msg, args...)) log.Tracef("SMTP[%v]<%v> %v", s.remoteHost, s.id, fmt.Sprintf(msg, args...))
} }
func (ss *Session) logInfo(msg string, args ...interface{}) { func (s *Session) logInfo(msg string, args ...interface{}) {
log.Infof("SMTP[%v]<%v> %v", ss.remoteHost, ss.id, fmt.Sprintf(msg, args...)) log.Infof("SMTP[%v]<%v> %v", s.remoteHost, s.id, fmt.Sprintf(msg, args...))
} }
func (ss *Session) logWarn(msg string, args ...interface{}) { func (s *Session) logWarn(msg string, args ...interface{}) {
// Update metrics // Update metrics
expWarnsTotal.Add(1) expWarnsTotal.Add(1)
log.Warnf("SMTP[%v]<%v> %v", ss.remoteHost, ss.id, fmt.Sprintf(msg, args...)) log.Warnf("SMTP[%v]<%v> %v", s.remoteHost, s.id, fmt.Sprintf(msg, args...))
} }
func (ss *Session) logError(msg string, args ...interface{}) { func (s *Session) logError(msg string, args ...interface{}) {
// Update metrics // Update metrics
expErrorsTotal.Add(1) expErrorsTotal.Add(1)
log.Errorf("SMTP[%v]<%v> %v", ss.remoteHost, ss.id, fmt.Sprintf(msg, args...)) log.Errorf("SMTP[%v]<%v> %v", s.remoteHost, s.id, fmt.Sprintf(msg, args...))
} }