support define_macros / undef_macros in setup.cfg

Lib/smtpd.py

 #! /usr/bin/env python3
-"""An RFC 5321 smtp proxy.
+"""An RFC 2821 smtp proxy.
 
 Usage: %(program)s [options] [localhost:localport [remotehost:remoteport]]
 
 Options:
 
     --nosetuid
     -n
         This program generally tries to setuid `nobody', unless this flag is
         set.  The setuid call will fail if this program is not run as root (in
         which case, use this flag).
 
     --version
     -V
         Print the version number and exit.
 
     --class classname
     -c classname
         Use `classname' as the concrete SMTP proxy class.  Uses `PureProxy' by
         default.
-
-    --size limit
-    -s limit
-        Restrict the total size of the incoming message to "limit" number of
-        bytes via the RFC 1870 SIZE extension.  Defaults to 33554432 bytes.
 
     --debug
     -d
         Turn on debugging prints.
 
     --help
     -h
         Print this message and exit.
 
 Version: %(__version__)s
 
 If localhost is not given then `localhost' is used, and if localport is not
 given then 8025 is used.  If remotehost is not given then `localhost' is used,
 and if remoteport is not given, then 25 is used.
 """
 
+
 # Overview:
 #
-# This file implements the minimal SMTP protocol as defined in RFC 5321.  It
+# This file implements the minimal SMTP protocol as defined in RFC 821.  It
 # has a hierarchy of classes which implement the backend functionality for the
 # smtpd.  A number of classes are provided:
 #
 #   SMTPServer - the base class for the backend.  Raises NotImplementedError
 #   if you try to use it.
 #
 #   DebuggingServer - simply prints each message it receives on stdout.
 #
 #   PureProxy - Proxies all messages to a real smtpd which does final
 #   delivery.  One known problem with this class is that it doesn't handle
 #   SMTP errors from the backend server at all.  This should be fixed
 #   (contributions are welcome!).
 #
 #   MailmanProxy - An experimental hack to work with GNU Mailman
 #   <www.list.org>.  Using this server as your real incoming smtpd, your
 #   mailhost will automatically recognize and accept mail destined to Mailman
 #   lists when those lists are created.  Every message not destined for a list
 #   gets forwarded to a real backend smtpd, as with PureProxy.  Again, errors
 #   are not handled correctly yet.
 #
 #
 # Author: Barry Warsaw <barry@python.org>
 #
 # TODO:
 #
 # - support mailbox delivery
 # - alias files
-# - Handle more ESMTP extensions
+# - ESMTP
 # - handle error codes from the backend smtpd
 
 import sys
 import os
 import errno
 import getopt
 import time
 import socket
 import asyncore
 import asynchat
-import collections
 from warnings import warn
-from email._header_value_parser import get_addr_spec, get_angle_addr
 
 __all__ = ["SMTPServer","DebuggingServer","PureProxy","MailmanProxy"]
 
 program = sys.argv[0]
-__version__ = 'Python SMTP proxy version 0.3'
+__version__ = 'Python SMTP proxy version 0.2'
 
 
 class Devnull:
     def write(self, msg): pass
     def flush(self): pass
 
 
 DEBUGSTREAM = Devnull()
 NEWLINE = '\n'
 EMPTYSTRING = ''
 COMMASPACE = ', '
-DATA_SIZE_DEFAULT = 33554432
 
 
+
 def usage(code, msg=''):
     print(__doc__ % globals(), file=sys.stderr)
     if msg:
         print(msg, file=sys.stderr)
     sys.exit(code)
 
 
+
 class SMTPChannel(asynchat.async_chat):
     COMMAND = 0
     DATA = 1
 
+    data_size_limit = 33554432
     command_size_limit = 512
-    command_size_limits = collections.defaultdict(lambda x=command_size_limit: x)
-    command_size_limits.update({
-        'MAIL': command_size_limit + 26,
-        })
-    max_command_size_limit = max(command_size_limits.values())
 
-    def __init__(self, server, conn, addr, data_size_limit=DATA_SIZE_DEFAULT):
+    def __init__(self, server, conn, addr):
         asynchat.async_chat.__init__(self, conn)
         self.smtp_server = server
         self.conn = conn
         self.addr = addr
-        self.data_size_limit = data_size_limit
         self.received_lines = []
         self.smtp_state = self.COMMAND
         self.seen_greeting = ''
         self.mailfrom = None
         self.rcpttos = []
         self.received_data = ''
         self.fqdn = socket.getfqdn()
         self.num_bytes = 0
         try:
             self.peer = conn.getpeername()
         except socket.error as err:
             # a race condition  may occur if the other end is closing
             # before we can get the peername
             self.close()
             if err.args[0] != errno.ENOTCONN:
                 raise
             return
         print('Peer:', repr(self.peer), file=DEBUGSTREAM)
         self.push('220 %s %s' % (self.fqdn, __version__))
         self.set_terminator(b'\r\n')
-        self.extended_smtp = False
 
     # properties for backwards-compatibility
     @property
     def __server(self):
         warn("Access to __server attribute on SMTPChannel is deprecated, "
             "use 'smtp_server' instead", DeprecationWarning, 2)
         return self.smtp_server
     @__server.setter
     def __server(self, value):
         warn("Setting __server attribute on SMTPChannel is deprecated, "
@@ skipping 111 matching lines @@
         self.addr = value
 
     # Overrides base class for convenience
     def push(self, msg):
         asynchat.async_chat.push(self, bytes(msg + '\r\n', 'ascii'))
 
     # Implementation of base class abstract method
     def collect_incoming_data(self, data):
         limit = None
         if self.smtp_state == self.COMMAND:
-            limit = self.max_command_size_limit
+            limit = self.command_size_limit
         elif self.smtp_state == self.DATA:
             limit = self.data_size_limit
         if limit and self.num_bytes > limit:
             return
         elif limit:
             self.num_bytes += len(data)
         self.received_lines.append(str(data, "utf-8"))
 
     # Implementation of base class abstract method
     def found_terminator(self):
         line = EMPTYSTRING.join(self.received_lines)
         print('Data:', repr(line), file=DEBUGSTREAM)
         self.received_lines = []
         if self.smtp_state == self.COMMAND:
-            sz, self.num_bytes = self.num_bytes, 0
+            if self.num_bytes > self.command_size_limit:
+                self.push('500 Error: line too long')
+                self.num_bytes = 0
+                return
+            self.num_bytes = 0
             if not line:
                 self.push('500 Error: bad syntax')
                 return
             method = None
             i = line.find(' ')
             if i < 0:
                 command = line.upper()
                 arg = None
             else:
                 command = line[:i].upper()
                 arg = line[i+1:].strip()
-            max_sz = (self.command_size_limits[command]
-                        if self.extended_smtp else self.command_size_limit)
-            if sz > max_sz:
-                self.push('500 Error: line too long')
-                return
             method = getattr(self, 'smtp_' + command, None)
             if not method:
-                self.push('500 Error: command "%s" not recognized' % command)
+                self.push('502 Error: command "%s" not implemented' % command)
                 return
             method(arg)
             return
         else:
             if self.smtp_state != self.DATA:
                 self.push('451 Internal confusion')
                 self.num_bytes = 0
                 return
-            if self.data_size_limit and self.num_bytes > self.data_size_limit:
+            if self.num_bytes > self.data_size_limit:
                 self.push('552 Error: Too much mail data')
                 self.num_bytes = 0
                 return
             # Remove extraneous carriage returns and de-transparency according
-            # to RFC 5321, Section 4.5.2.
+            # to RFC 821, Section 4.5.2.
             data = []
             for text in line.split('\r\n'):
                 if text and text[0] == '.':
                     data.append(text[1:])
                 else:
                     data.append(text)
             self.received_data = NEWLINE.join(data)
             status = self.smtp_server.process_message(self.peer,
                                                       self.mailfrom,
                                                       self.rcpttos,
                                                       self.received_data)
             self.rcpttos = []
             self.mailfrom = None
             self.smtp_state = self.COMMAND
             self.num_bytes = 0
             self.set_terminator(b'\r\n')
             if not status:
-                self.push('250 OK')
+                self.push('250 Ok')
             else:
                 self.push(status)
 
     # SMTP and ESMTP commands
     def smtp_HELO(self, arg):
         if not arg:
             self.push('501 Syntax: HELO hostname')
             return
         if self.seen_greeting:
             self.push('503 Duplicate HELO/EHLO')
         else:
             self.seen_greeting = arg
-            self.extended_smtp = False
             self.push('250 %s' % self.fqdn)
-
-    def smtp_EHLO(self, arg):
-        if not arg:
-            self.push('501 Syntax: EHLO hostname')
-            return
-        if self.seen_greeting:
-            self.push('503 Duplicate HELO/EHLO')
-        else:
-            self.seen_greeting = arg
-            self.extended_smtp = True
-            self.push('250-%s' % self.fqdn)
-            if self.data_size_limit:
-                self.push('250-SIZE %s' % self.data_size_limit)
-            self.push('250 HELP')
 
     def smtp_NOOP(self, arg):
         if arg:
             self.push('501 Syntax: NOOP')
         else:
-            self.push('250 OK')
+            self.push('250 Ok')
 
     def smtp_QUIT(self, arg):
         # args is ignored
         self.push('221 Bye')
         self.close_when_done()
 
-    def _strip_command_keyword(self, keyword, arg):
+    # factored
+    def __getaddr(self, keyword, arg):
+        address = None
         keylen = len(keyword)
         if arg[:keylen].upper() == keyword:
-            return arg[keylen:].strip()
-        return ''
-
-    def _getaddr(self, arg):
-        if not arg:
-            return '', ''
-        if arg.lstrip().startswith('<'):
-            address, rest = get_angle_addr(arg)
-        else:
-            address, rest = get_addr_spec(arg)
-        if not address:
-            return address, rest
-        return address.addr_spec, rest
-
-    def _getparams(self, params):
-        # Return any parameters that appear to be syntactically valid according
-        # to RFC 1869, ignore all others.  (Postel rule: accept what we can.)
-        params = [param.split('=', 1) for param in params.split()
-                                      if '=' in param]
-        return {k: v for k, v in params if k.isalnum()}
-
-    def smtp_HELP(self, arg):
-        if arg:
-            extended = ' [SP <mail parameters]'
-            lc_arg = arg.upper()
-            if lc_arg == 'EHLO':
-                self.push('250 Syntax: EHLO hostname')
-            elif lc_arg == 'HELO':
-                self.push('250 Syntax: HELO hostname')
-            elif lc_arg == 'MAIL':
-                msg = '250 Syntax: MAIL FROM: <address>'
-                if self.extended_smtp:
-                    msg += extended
-                self.push(msg)
-            elif lc_arg == 'RCPT':
-                msg = '250 Syntax: RCPT TO: <address>'
-                if self.extended_smtp:
-                    msg += extended
-                self.push(msg)
-            elif lc_arg == 'DATA':
-                self.push('250 Syntax: DATA')
-            elif lc_arg == 'RSET':
-                self.push('250 Syntax: RSET')
-            elif lc_arg == 'NOOP':
-                self.push('250 Syntax: NOOP')
-            elif lc_arg == 'QUIT':
-                self.push('250 Syntax: QUIT')
-            elif lc_arg == 'VRFY':
-                self.push('250 Syntax: VRFY <address>')
-            else:
-                self.push('501 Supported commands: EHLO HELO MAIL RCPT '
-                          'DATA RSET NOOP QUIT VRFY')
-        else:
-            self.push('250 Supported commands: EHLO HELO MAIL RCPT DATA '
-                      'RSET NOOP QUIT VRFY')
-
-    def smtp_VRFY(self, arg):
-        if arg:
-            address, params = self._getaddr(arg)
-            if address:
-                self.push('252 Cannot VRFY user, but will accept message '
-                          'and attempt delivery')
-            else:
-                self.push('502 Could not VRFY %s' % arg)
-        else:
-            self.push('501 Syntax: VRFY <address>')
+            address = arg[keylen:].strip()
+            if not address:
+                pass
+            elif address[0] == '<' and address[-1] == '>' and address != '<>':
+                # Addresses can be in the form <person@dom.com> but watch out
+                # for null address, e.g. <>
+                address = address[1:-1]
+        return address
 
     def smtp_MAIL(self, arg):
         if not self.seen_greeting:
             self.push('503 Error: send HELO first');
             return
+
         print('===> MAIL', arg, file=DEBUGSTREAM)
-        syntaxerr = '501 Syntax: MAIL FROM: <address>'
-        if self.extended_smtp:
-            syntaxerr += ' [SP <mail-parameters>]'
-        if arg is None:
-            self.push(syntaxerr)
-            return
-        arg = self._strip_command_keyword('FROM:', arg)
-        address, params = self._getaddr(arg)
+        address = self.__getaddr('FROM:', arg) if arg else None
         if not address:
-            self.push(syntaxerr)
-            return
-        if not self.extended_smtp and params:
-            self.push(syntaxerr)
-            return
-        if not address:
-            self.push(syntaxerr)
+            self.push('501 Syntax: MAIL FROM:<address>')
             return
         if self.mailfrom:
             self.push('503 Error: nested MAIL command')
             return
-        params = self._getparams(params.upper())
-        if params is None:
-            self.push(syntaxerr)
-            return
-        size = params.pop('SIZE', None)
-        if size:
-            if not size.isdigit():
-                self.push(syntaxerr)
-                return
-            elif self.data_size_limit and int(size) > self.data_size_limit:
-                self.push('552 Error: message size exceeds fixed maximum message size')
-                return
-        if len(params.keys()) > 0:
-            self.push('555 MAIL FROM parameters not recognized or not implemented')
-            return
         self.mailfrom = address
         print('sender:', self.mailfrom, file=DEBUGSTREAM)
-        self.push('250 OK')
+        self.push('250 Ok')
 
     def smtp_RCPT(self, arg):
         if not self.seen_greeting:
             self.push('503 Error: send HELO first');
             return
+
         print('===> RCPT', arg, file=DEBUGSTREAM)
         if not self.mailfrom:
             self.push('503 Error: need MAIL command')
             return
-        syntaxerr = '501 Syntax: RCPT TO: <address>'
-        if self.extended_smtp:
-            syntaxerr += ' [SP <mail-parameters>]'
-        if arg is None:
-            self.push(syntaxerr)
-            return
-        arg = self._strip_command_keyword('TO:', arg)
-        address, params = self._getaddr(arg)
-        if not address:
-            self.push(syntaxerr)
-            return
-        if params:
-            if self.extended_smtp:
-                params = self._getparams(params.upper())
-                if params is None:
-                    self.push(syntaxerr)
-                    return
-            else:
-                self.push(syntaxerr)
-                return
-        if not address:
-            self.push(syntaxerr)
-            return
-        if params and len(params.keys()) > 0:
-            self.push('555 RCPT TO parameters not recognized or not implemented')
-            return
+        address = self.__getaddr('TO:', arg) if arg else None
         if not address:
             self.push('501 Syntax: RCPT TO: <address>')
             return
         self.rcpttos.append(address)
         print('recips:', self.rcpttos, file=DEBUGSTREAM)
-        self.push('250 OK')
+        self.push('250 Ok')
 
     def smtp_RSET(self, arg):
         if arg:
             self.push('501 Syntax: RSET')
             return
         # Resets the sender, recipients, and data, but not the greeting
         self.mailfrom = None
         self.rcpttos = []
         self.received_data = ''
         self.smtp_state = self.COMMAND
-        self.push('250 OK')
+        self.push('250 Ok')
 
     def smtp_DATA(self, arg):
         if not self.seen_greeting:
             self.push('503 Error: send HELO first');
             return
+
         if not self.rcpttos:
             self.push('503 Error: need RCPT command')
             return
         if arg:
             self.push('501 Syntax: DATA')
             return
         self.smtp_state = self.DATA
         self.set_terminator(b'\r\n.\r\n')
         self.push('354 End data with <CR><LF>.<CR><LF>')
 
-    # Commands that have not been implemented
-    def smtp_EXPN(self, arg):
-        self.push('502 EXPN not implemented')
 
-
+
 class SMTPServer(asyncore.dispatcher):
     # SMTPChannel class to use for managing client connections
     channel_class = SMTPChannel
 
-    def __init__(self, localaddr, remoteaddr,
-                 data_size_limit=DATA_SIZE_DEFAULT):
+    def __init__(self, localaddr, remoteaddr):
         self._localaddr = localaddr
         self._remoteaddr = remoteaddr
-        self.data_size_limit = data_size_limit
         asyncore.dispatcher.__init__(self)
         try:
             self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
             # try to re-use a server port if possible
             self.set_reuse_addr()
             self.bind(localaddr)
             self.listen(5)
         except:
             self.close()
             raise
         else:
             print('%s started at %s\n\tLocal addr: %s\n\tRemote addr:%s' % (
                 self.__class__.__name__, time.ctime(time.time()),
                 localaddr, remoteaddr), file=DEBUGSTREAM)
 
     def handle_accepted(self, conn, addr):
         print('Incoming connection from %s' % repr(addr), file=DEBUGSTREAM)
-        channel = self.channel_class(self, conn, addr, self.data_size_limit)
+        channel = self.channel_class(self, conn, addr)
 
     # API for "doing something useful with the message"
     def process_message(self, peer, mailfrom, rcpttos, data):
         """Override this abstract method to handle messages from the client.
 
         peer is a tuple containing (ipaddr, port) of the client that made the
         socket connection to our smtp port.
 
         mailfrom is the raw address the client claims the message is coming
         from.
 
         rcpttos is a list of raw addresses the client wishes to deliver the
         message to.
 
         data is a string containing the entire full text of the message,
         headers (if supplied) and all.  It has been `de-transparencied'
         according to RFC 821, Section 4.5.2.  In other words, a line
         containing a `.' followed by other text has had the leading dot
         removed.
 
         This function should return None, for a normal `250 Ok' response;
         otherwise it returns the desired response string in RFC 821 format.
 
         """
         raise NotImplementedError
 
 
+
 class DebuggingServer(SMTPServer):
     # Do something with the gathered message
     def process_message(self, peer, mailfrom, rcpttos, data):
         inheaders = 1
         lines = data.split('\n')
         print('---------- MESSAGE FOLLOWS ----------')
         for line in lines:
             # headers first
             if inheaders and not line:
                 print('X-Peer:', peer[0])
                 inheaders = 0
             print(line)
         print('------------ END MESSAGE ------------')
 
 
+
 class PureProxy(SMTPServer):
     def process_message(self, peer, mailfrom, rcpttos, data):
         lines = data.split('\n')
         # Look for the last header
         i = 0
         for line in lines:
             if not line:
                 break
             i += 1
         lines.insert(i, 'X-Peer: %s' % peer[0])
@@ skipping 20 matching lines @@
             # All recipients were refused.  If the exception had an associated
             # error code, use it.  Otherwise,fake it with a non-triggering
             # exception code.
             errcode = getattr(e, 'smtp_code', -1)
             errmsg = getattr(e, 'smtp_error', 'ignore')
             for r in rcpttos:
                 refused[r] = (errcode, errmsg)
         return refused
 
 
+
 class MailmanProxy(PureProxy):
     def process_message(self, peer, mailfrom, rcpttos, data):
         from io import StringIO
         from Mailman import Utils
         from Mailman import Message
         from Mailman import MailList
         # If the message is to a Mailman mailing list, then we'll invoke the
         # Mailman script directly, without going through the real smtpd.
         # Otherwise we'll forward it to the local proxy for disposition.
         listnames = []
@@ skipping 58 matching lines @@
                 msg.Enqueue(mlist, torequest=1)
             elif command in ('join', 'leave'):
                 # TBD: this is a hack!
                 if command == 'join':
                     msg['Subject'] = 'subscribe'
                 else:
                     msg['Subject'] = 'unsubscribe'
                 msg.Enqueue(mlist, torequest=1)
 
 
+
 class Options:
     setuid = 1
     classname = 'PureProxy'
-    size_limit = None
 
 
+
 def parseargs():
     global DEBUGSTREAM
     try:
         opts, args = getopt.getopt(
-            sys.argv[1:], 'nVhc:s:d',
-            ['class=', 'nosetuid', 'version', 'help', 'size=', 'debug'])
+            sys.argv[1:], 'nVhc:d',
+            ['class=', 'nosetuid', 'version', 'help', 'debug'])
     except getopt.error as e:
         usage(1, e)
 
     options = Options()
     for opt, arg in opts:
         if opt in ('-h', '--help'):
             usage(0)
         elif opt in ('-V', '--version'):
             print(__version__, file=sys.stderr)
             sys.exit(0)
         elif opt in ('-n', '--nosetuid'):
             options.setuid = 0
         elif opt in ('-c', '--class'):
             options.classname = arg
         elif opt in ('-d', '--debug'):
             DEBUGSTREAM = sys.stderr
-        elif opt in ('-s', '--size'):
-            try:
-                int_size = int(arg)
-                options.size_limit = int_size
-            except:
-                print('Invalid size: ' + arg, file=sys.stderr)
-                sys.exit(1)
 
     # parse the rest of the arguments
     if len(args) < 1:
         localspec = 'localhost:8025'
         remotespec = 'localhost:25'
     elif len(args) < 2:
         localspec = args[0]
         remotespec = 'localhost:25'
     elif len(args) < 3:
         localspec = args[0]
@@ skipping 14 matching lines @@
     if i < 0:
         usage(1, 'Bad remote spec: %s' % remotespec)
     options.remotehost = remotespec[:i]
     try:
         options.remoteport = int(remotespec[i+1:])
     except ValueError:
         usage(1, 'Bad remote port: %s' % remotespec)
     return options
 
 
+
 if __name__ == '__main__':
     options = parseargs()
     # Become nobody
     classname = options.classname
     if "." in classname:
         lastdot = classname.rfind(".")
         mod = __import__(classname[:lastdot], globals(), locals(), [""])
         classname = classname[lastdot+1:]
     else:
         import __main__ as mod
     class_ = getattr(mod, classname)
     proxy = class_((options.localhost, options.localport),
-                   (options.remotehost, options.remoteport),
-                   options.size_limit)
+                   (options.remotehost, options.remoteport))
     if options.setuid:
         try:
             import pwd
         except ImportError:
             print('Cannot import module "pwd"; try running with -n option.', file=sys.stderr)
             sys.exit(1)
         nobody = pwd.getpwnam('nobody')[2]
         try:
             os.setuid(nobody)
         except OSError as e:
             if e.errno != errno.EPERM: raise
             print('Cannot setuid "nobody"; try running with -n option.', file=sys.stderr)
             sys.exit(1)
     try:
         asyncore.loop()
     except KeyboardInterrupt:
         pass