Hi!
We have a need for an SMTP server, and found the current implementation
a bit fragile. This patch should robustify it, and also improve RFC 2821
compliance (no guarantees though).
I didn't touch the SMTP client (apart from adding the double-dot protocol),
but I suspect I'll look over it as well.
Comments, etc are welcome. The patch is relative to twisted CVS as of a
few minutes ago.
Regards,
/Anders
--
-- Of course I'm crazy, but that doesn't mean I'm wrong.
Anders Hammarquist | iko(a)strakt.com
AB Strakt | Tel: +46 31 711 08 70
G|teborg, Sweden. RADIO: SM6XMM and N2JGL | Fax: +46 31 711 08 80
Index: twisted/protocols/basic.py
===================================================================
RCS file: /cvs/Twisted/twisted/protocols/basic.py,v
retrieving revision 1.23
diff -u -u -r1.23 basic.py
--- twisted/protocols/basic.py 23 Sep 2002 08:51:29 -0000 1.23
+++ twisted/protocols/basic.py 30 Sep 2002 14:49:24 -0000
@@ -150,12 +150,14 @@
line, self.__buffer = self.__buffer.split(self.delimiter, 1)
except ValueError:
if len(self.__buffer) > self.MAX_LENGTH:
- self.transport.loseConnection()
+ line, self.__buffer = self.__buffer, ''
+ self.lineLengthExceeded(line)
return
break
else:
if len(line) > self.MAX_LENGTH:
- self.transport.loseConnection()
+ line, self.__buffer = self.__buffer, ''
+ self.lineLengthExceeded(line)
return
self.lineReceived(line)
if self.transport.disconnecting:
@@ -197,6 +199,12 @@
"""Sends a line to the other end of the connection.
"""
self.transport.write(line + self.delimiter)
+
+ def lineLengthExceeded(self, line):
+ """Called when the maximum line length has been reached.
+ Override if it needs to be dealt with in some special way.
+ """
+ self.transport.loseConnection()
class Int32StringReceiver(protocol.Protocol):
Index: twisted/protocols/smtp.py
===================================================================
RCS file: /cvs/Twisted/twisted/protocols/smtp.py,v
retrieving revision 1.23
diff -u -u -r1.23 smtp.py
--- twisted/protocols/smtp.py 19 Aug 2002 03:21:58 -0000 1.23
+++ twisted/protocols/smtp.py 30 Sep 2002 14:49:24 -0000
@@ -18,10 +18,10 @@
"""
from twisted.protocols import basic
-from twisted.internet import protocol, defer
+from twisted.internet import protocol, defer, reactor
from twisted.python import log
-import os, time, string, operator
+import os, time, string, operator, re
class SMTPError(Exception):
pass
@@ -49,15 +49,93 @@
self.deferred.errback(arg)
self.done = 1
+class AddressError(SMTPError):
+ "Parse error in address"
+ pass
+
+# Character classes for parsing addresses
+atom = r"-A-Za-z0-9!#$%&'*+/=?^_`{|}~"
+
+class Address:
+ """Parse and hold an RFC 2821 address.
+
+ Source routes are stipped and ignored, UUCP-style bang-paths
+ and %-style routing are not parsed.
+ """
+
+ qstring = re.compile(r'((?:"[^"]*"|\\.|[' + atom + r'])+|.)')
+
+ def __init__(self, addr):
+ self.local = ''
+ self.domain = ''
+ self.addrstr = addr
+
+ # Tokenize
+ atl = filter(None,self.qstring.split(addr))
+
+ local = []
+ domain = []
+
+ while atl:
+ if atl[0] == '<':
+ if atl[-1] != '>':
+ raise AddressError, "Unbalanced <>"
+ atl = atl[1:-1]
+ elif atl[0] == '@':
+ atl = atl[1:]
+ if not local:
+ # Source route
+ while atl and atl[0] != ':':
+ # remove it
+ atl = atl[1:]
+ if not atl:
+ raise AddressError, "Malformed source route"
+ atl = atl[1:] # remove :
+ elif domain:
+ raise AddressError, "Too many @"
+ else:
+ # Now in domain
+ domain = ['']
+ elif len(atl[0]) == 1 and atl[0] not in atom + '.':
+ raise AddressError, "Parse error at " + atl[0]
+ else:
+ if not domain:
+ local.append(atl[0])
+ else:
+ domain.append(atl[0])
+ atl = atl[1:]
+
+ self.local = ''.join(local)
+ self.domain = ''.join(domain)
+
+ dequotebs = re.compile(r'\\(.)')
+ def dequote(self, addr):
+ "Remove RFC-2821 quotes from address"
+ res = []
+
+ atl = filter(None,self.qstring.split(addr))
+
+ for t in atl:
+ if t[0] == '"' and t[-1] == '"':
+ res.append(t[1:-1])
+ elif '\\' in t:
+ res.append(self.dequotebs.sub(r'\1',t))
+ else:
+ res.append(t)
+
+ return ''.join(res)
+
+ def __str__(self):
+ return '%s%s' % (self.local, self.domain and ("@" + self.domain) or "")
+
+ def __repr__(self):
+ return "%s.%s(%s)" % (self.__module__, self.__class__.__name__,
+ repr(str(self)))
-class User:
+class User(Address):
def __init__(self, destination, helo, protocol, orig):
- try:
- self.name, self.domain = string.split(destination, '@', 1)
- except ValueError:
- self.name = destination
- self.domain = ''
+ Address.__init__(self,destination)
self.helo = helo
self.protocol = protocol
self.orig = orig
@@ -83,23 +161,41 @@
class SMTP(basic.LineReceiver):
- def __init__(self):
+ def __init__(self, domain=None, timeout=600):
self.mode = COMMAND
self.__from = None
self.__helo = None
- self.__to = ()
+ self.__to = []
+ self.timeout = timeout
+ if not domain:
+ import socket
+ domain = socket.getfqdn()
+ self.host = domain
+
+ def timedout(self):
+ self.sendCode(421, '%s Timeout. Try talking faster next time!' %
+ self.host)
+ self.transport.loseConnection()
def connectionMade(self):
- self.sendCode(220, 'Spammers beware, your ass is on fire')
+ self.sendCode(220, '%s Spammers beware, your ass is on fire' %
+ self.host)
+ self.timeoutID = reactor.callLater(self.timeout, self.timedout)
def sendCode(self, code, message=''):
"Send an SMTP code with a message."
self.transport.write('%d %s\r\n' % (code, message))
def lineReceived(self, line):
+ self.timeoutID.cancel()
+ self.timeoutID = reactor.callLater(self.timeout, self.timedout)
+
if self.mode is DATA:
return self.dataLineReceived(line)
- command = string.split(line, None, 1)[0]
+ if line:
+ command = string.split(line, None, 1)[0]
+ else:
+ command = ''
method = getattr(self, 'do_'+string.upper(command), None)
if method is None:
method = self.do_UNKNOWN
@@ -107,21 +203,59 @@
line = line[len(command):]
return method(string.strip(line))
+ def lineLengthExceeded(self, line):
+ if self.mode is DATA:
+ for message in self.__messages:
+ message.connectionLost()
+ self.mode = COMMAND
+ del self.__messages
+ self.sendCode(500, 'Line too long')
+
def do_UNKNOWN(self, rest):
- self.sendCode(502, 'Command not implemented')
+ self.sendCode(500, 'Command not implemented')
def do_HELO(self, rest):
- self.__helo = rest
- self.sendCode(250, 'Nice to meet you')
+ peer = self.transport.getPeer()[1]
+ self.__helo = (rest, peer)
+ self.sendCode(250, '%s Hello %s, nice to meet you' % (self.host, peer))
def do_QUIT(self, rest):
self.sendCode(221, 'See you later')
self.transport.loseConnection()
+ qstring = r'("[^"]*"|\\.|[' + atom + r'@.])+'
+
+ path_re = re.compile(r"(<(?=.*>))?(?P<addr><>|(?<=<)" + qstring + r"(?=(?<!\\)>)|" + qstring + r")((?<![\\<])>)?$")
+ mail_re = re.compile(r'\s*FROM:\s*(?P<path><>|<' + qstring + r'>|' +
+ qstring + r')\s*(?P<opts>.*)$',re.I)
+ rcpt_re = re.compile(r'\s*TO:\s*(?P<path><' + qstring + r'>|' +
+ qstring + r')\s*(?P<opts>.*)$',re.I)
+
def do_MAIL(self, rest):
- from_ = rest[len("MAIL:<"):-len(">")]
- self.validateFrom(self.__helo, from_, self._fromValid,
- self._fromInvalid)
+ if not self.__helo:
+ self.sendCode(503,"Who are you? Say HELO first");
+ if self.__from:
+ self.sendCode(503,"Only one sender per message, please")
+ return
+ # Clear old recipient list
+ self.__to = []
+ m = self.mail_re.match(rest)
+ if not m:
+ self.sendCode(501, "Syntax error")
+ return
+ m = self.path_re.match(m.group('path'))
+ if not m:
+ self.sendCode(553, "Unparseable address")
+ return
+
+ try:
+ addr = Address(m.group('addr'))
+ except AddressError, e:
+ self.sendCode(553, str(e))
+ return
+
+ self.validateFrom(self.__helo, addr, self._fromValid,
+ self._fromInvalid)
def _fromValid(self, from_):
self.__from = from_
@@ -131,12 +265,28 @@
self.sendCode(550, 'No mail for you!')
def do_RCPT(self, rest):
- to = rest[len("TO:<"):-len(">")]
- user = User(to, self.__helo, self, self.__from)
+ if not self.__from:
+ self.sendCode(503, "Must have sender before recpient")
+ return
+ m = self.rcpt_re.match(rest)
+ if not m:
+ self.sendCode(501, "Syntax error")
+ return
+ m = self.path_re.match(m.group('path'))
+ if not m:
+ self.sendCode(553, "Unparseable address")
+ return
+
+ try:
+ user = User(m.group('addr'), self.__helo, self, self.__from)
+ except AddressError, e:
+ self.sendCode(553, str(e))
+ return
+
self.validateTo(user, self._toValid, self._toInvalid)
def _toValid(self, to):
- self.__to = self.__to + (to,)
+ self.__to.append(to)
self.sendCode(250, 'Address recognized')
def _toInvalid(self, to):
@@ -144,22 +294,29 @@
def do_DATA(self, rest):
if self.__from is None or not self.__to:
- self.sendCode(550, 'Must have valid receiver and originator')
+ self.sendCode(503, 'Must have valid receiver and originator')
return
self.mode = DATA
helo, origin, recipients = self.__helo, self.__from, self.__to
self.__from = None
- self.__to = ()
+ self.__to = []
self.__messages = self.startMessage(recipients)
+ for message in self.__messages:
+ message.lineReceived(self.receivedHeader(helo, origin, recipients))
self.sendCode(354, 'Continue')
def connectionLost(self, reason):
+ # self.sendCode(421, 'Loosing connection.') # This does nothing...
+ # Ideally, if we (rather than the other side) lose the connection,
+ # we should be able to tell the other side that we are going away.
+ # RFC-2821 requires that we try.
if self.mode is DATA:
for message in self.__messages:
message.connectionLost()
def do_RSET(self, rest):
- self.__init__()
+ self.__from = None
+ self.__to = []
self.sendCode(250, 'I remember nothing.')
def dataLineReceived(self, line):
@@ -177,6 +334,7 @@
deferred = message.eomReceived()
deferred.addCallback(ndeferred.callback)
deferred.addErrback(ndeferred.errback)
+ del self.__messages
return
line = line[1:]
for message in self.__messages:
@@ -189,6 +347,11 @@
self.sendCode(550, 'Could not send e-mail')
# overridable methods:
+ def receivedHeader(self, helo, origin, recipents):
+ return "Received: From %s ([%s]) by %s; %s" % (
+ helo[0], helo[1], self.host,
+ time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime()))
+
def validateFrom(self, helo, origin, success, failure):
success(origin)
@@ -281,6 +444,7 @@
self.state = 'afterData'
chunk = string.replace(chunk, "\n", "\r\n")
+ chunk = string.replace(chunk, "\r\n.", "\r\n..")
self.transport.write(chunk)
def pauseProducing(self):
