1 #! /usr/bin/env python

     2 """An RFC 2821 smtp proxy.

     3 

     4 Usage: %(program)s [options] [localhost:localport [remotehost:remoteport]]

     5 

     6 Options:

     7 

     8     --nosetuid

     9     -n

    10         This program generally tries to setuid `nobody', unless this flag is

    11         set.  The setuid call will fail if this program is not run as root (in

    12         which case, use this flag).

    13 

    14     --version

    15     -V

    16         Print the version number and exit.

    17 

    18     --class classname

    19     -c classname

    20         Use `classname' as the concrete SMTP proxy class.  Uses `PureProxy' by

    21         default.

    22 

    23     --debug

    24     -d

    25         Turn on debugging prints.

    26 

    27     --help

    28     -h

    29         Print this message and exit.

    30 

    31 Version: %(__version__)s

    32 

    33 If localhost is not given then `localhost' is used, and if localport is not

    34 given then 8025 is used.  If remotehost is not given then `localhost' is used,

    35 and if remoteport is not given, then 25 is used.

    36 """

    37 

    38 

    39 # Overview:

    40 #

    41 # This file implements the minimal SMTP protocol as defined in RFC 821.  It

    42 # has a hierarchy of classes which implement the backend functionality for the

    43 # smtpd.  A number of classes are provided:

    44 #

    45 #   SMTPServer - the base class for the backend.  Raises NotImplementedError

    46 #   if you try to use it.

    47 #

    48 #   DebuggingServer - simply prints each message it receives on stdout.

    49 #

    50 #   PureProxy - Proxies all messages to a real smtpd which does final

    51 #   delivery.  One known problem with this class is that it doesn't handle

    52 #   SMTP errors from the backend server at all.  This should be fixed

    53 #   (contributions are welcome!).

    54 #

    55 #   MailmanProxy - An experimental hack to work with GNU Mailman

    56 #   <www.list.org>.  Using this server as your real incoming smtpd, your

    57 #   mailhost will automatically recognize and accept mail destined to Mailman

    58 #   lists when those lists are created.  Every message not destined for a list

    59 #   gets forwarded to a real backend smtpd, as with PureProxy.  Again, errors

    60 #   are not handled correctly yet.

    61 #

    62 # Please note that this script requires Python 2.0

    63 #

    64 # Author: Barry Warsaw <barry@python.org>

    65 #

    66 # TODO:

    67 #

    68 # - support mailbox delivery

    69 # - alias files

    70 # - ESMTP

    71 # - handle error codes from the backend smtpd

    72 

    73 import sys

    74 import os

    75 import errno

    76 import getopt

    77 import time

    78 import socket

    79 import asyncore

    80 import asynchat

    81 

    82 __all__ = ["SMTPServer","DebuggingServer","PureProxy","MailmanProxy"]

    83 

    84 program = sys.argv[0]

    85 __version__ = 'Python SMTP proxy version 0.2'

    86 

    87 

    88 class Devnull:

    89     def write(self, msg): pass

    90     def flush(self): pass

    91 

    92 

    93 DEBUGSTREAM = Devnull()

    94 NEWLINE = '\n'

    95 EMPTYSTRING = ''

    96 COMMASPACE = ', '

    97 

    98 

    99 

   100 def usage(code, msg=''):

   101     print >> sys.stderr, __doc__ % globals()

   102     if msg:

   103         print >> sys.stderr, msg

   104     sys.exit(code)

   105 

   106 

   107 

   108 class SMTPChannel(asynchat.async_chat):

   109     COMMAND = 0

   110     DATA = 1

   111 

   112     def __init__(self, server, conn, addr):

   113         asynchat.async_chat.__init__(self, conn)

   114         self.__server = server

   115         self.__conn = conn

   116         self.__addr = addr

   117         self.__line = []

   118         self.__state = self.COMMAND

   119         self.__greeting = 0

   120         self.__mailfrom = None

   121         self.__rcpttos = []

   122         self.__data = ''

   123         self.__fqdn = socket.getfqdn()

   124         self.__peer = conn.getpeername()

   125         print >> DEBUGSTREAM, 'Peer:', repr(self.__peer)

   126         self.push('220 %s %s' % (self.__fqdn, __version__))

   127         self.set_terminator('\r\n')

   128 

   129     # Overrides base class for convenience

   130     def push(self, msg):

   131         asynchat.async_chat.push(self, msg + '\r\n')

   132 

   133     # Implementation of base class abstract method

   134     def collect_incoming_data(self, data):

   135         self.__line.append(data)

   136 

   137     # Implementation of base class abstract method

   138     def found_terminator(self):

   139         line = EMPTYSTRING.join(self.__line)

   140         print >> DEBUGSTREAM, 'Data:', repr(line)

   141         self.__line = []

   142         if self.__state == self.COMMAND:

   143             if not line:

   144                 self.push('500 Error: bad syntax')

   145                 return

   146             method = None

   147             i = line.find(' ')

   148             if i < 0:

   149                 command = line.upper()

   150                 arg = None

   151             else:

   152                 command = line[:i].upper()

   153                 arg = line[i+1:].strip()

   154             method = getattr(self, 'smtp_' + command, None)

   155             if not method:

   156                 self.push('502 Error: command "%s" not implemented' % command)

   157                 return

   158             method(arg)

   159             return

   160         else:

   161             if self.__state != self.DATA:

   162                 self.push('451 Internal confusion')

   163                 return

   164             # Remove extraneous carriage returns and de-transparency according

   165             # to RFC 821, Section 4.5.2.

   166             data = []

   167             for text in line.split('\r\n'):

   168                 if text and text[0] == '.':

   169                     data.append(text[1:])

   170                 else:

   171                     data.append(text)

   172             self.__data = NEWLINE.join(data)

   173             status = self.__server.process_message(self.__peer,

   174                                                    self.__mailfrom,

   175                                                    self.__rcpttos,

   176                                                    self.__data)

   177             self.__rcpttos = []

   178             self.__mailfrom = None

   179             self.__state = self.COMMAND

   180             self.set_terminator('\r\n')

   181             if not status:

   182                 self.push('250 Ok')

   183             else:

   184                 self.push(status)

   185 

   186     # SMTP and ESMTP commands

   187     def smtp_HELO(self, arg):

   188         if not arg:

   189             self.push('501 Syntax: HELO hostname')

   190             return

   191         if self.__greeting:

   192             self.push('503 Duplicate HELO/EHLO')

   193         else:

   194             self.__greeting = arg

   195             self.push('250 %s' % self.__fqdn)

   196 

   197     def smtp_NOOP(self, arg):

   198         if arg:

   199             self.push('501 Syntax: NOOP')

   200         else:

   201             self.push('250 Ok')

   202 

   203     def smtp_QUIT(self, arg):

   204         # args is ignored

   205         self.push('221 Bye')

   206         self.close_when_done()

   207 

   208     # factored

   209     def __getaddr(self, keyword, arg):

   210         address = None

   211         keylen = len(keyword)

   212         if arg[:keylen].upper() == keyword:

   213             address = arg[keylen:].strip()

   214             if not address:

   215                 pass

   216             elif address[0] == '<' and address[-1] == '>' and address != '<>':

   217                 # Addresses can be in the form <person@dom.com> but watch out

   218                 # for null address, e.g. <>

   219                 address = address[1:-1]

   220         return address

   221 

   222     def smtp_MAIL(self, arg):

   223         print >> DEBUGSTREAM, '===> MAIL', arg

   224         address = self.__getaddr('FROM:', arg) if arg else None

   225         if not address:

   226             self.push('501 Syntax: MAIL FROM:<address>')

   227             return

   228         if self.__mailfrom:

   229             self.push('503 Error: nested MAIL command')

   230             return

   231         self.__mailfrom = address

   232         print >> DEBUGSTREAM, 'sender:', self.__mailfrom

   233         self.push('250 Ok')

   234 

   235     def smtp_RCPT(self, arg):

   236         print >> DEBUGSTREAM, '===> RCPT', arg

   237         if not self.__mailfrom:

   238             self.push('503 Error: need MAIL command')

   239             return

   240         address = self.__getaddr('TO:', arg) if arg else None

   241         if not address:

   242             self.push('501 Syntax: RCPT TO: <address>')

   243             return

   244         self.__rcpttos.append(address)

   245         print >> DEBUGSTREAM, 'recips:', self.__rcpttos

   246         self.push('250 Ok')

   247 

   248     def smtp_RSET(self, arg):

   249         if arg:

   250             self.push('501 Syntax: RSET')

   251             return

   252         # Resets the sender, recipients, and data, but not the greeting

   253         self.__mailfrom = None

   254         self.__rcpttos = []

   255         self.__data = ''

   256         self.__state = self.COMMAND

   257         self.push('250 Ok')

   258 

   259     def smtp_DATA(self, arg):

   260         if not self.__rcpttos:

   261             self.push('503 Error: need RCPT command')

   262             return

   263         if arg:

   264             self.push('501 Syntax: DATA')

   265             return

   266         self.__state = self.DATA

   267         self.set_terminator('\r\n.\r\n')

   268         self.push('354 End data with <CR><LF>.<CR><LF>')

   269 

   270 

   271 

   272 class SMTPServer(asyncore.dispatcher):

   273     def __init__(self, localaddr, remoteaddr):

   274         self._localaddr = localaddr

   275         self._remoteaddr = remoteaddr

   276         asyncore.dispatcher.__init__(self)

   277         self.create_socket(socket.AF_INET, socket.SOCK_STREAM)

   278         # try to re-use a server port if possible

   279         self.set_reuse_addr()

   280         self.bind(localaddr)

   281         self.listen(5)

   282         print >> DEBUGSTREAM, \

   283               '%s started at %s\n\tLocal addr: %s\n\tRemote addr:%s' % (

   284             self.__class__.__name__, time.ctime(time.time()),

   285             localaddr, remoteaddr)

   286 

   287     def handle_accept(self):

   288         conn, addr = self.accept()

   289         print >> DEBUGSTREAM, 'Incoming connection from %s' % repr(addr)

   290         channel = SMTPChannel(self, conn, addr)

   291 

   292     # API for "doing something useful with the message"

   293     def process_message(self, peer, mailfrom, rcpttos, data):

   294         """Override this abstract method to handle messages from the client.

   295 

   296         peer is a tuple containing (ipaddr, port) of the client that made the

   297         socket connection to our smtp port.

   298 

   299         mailfrom is the raw address the client claims the message is coming

   300         from.

   301 

   302         rcpttos is a list of raw addresses the client wishes to deliver the

   303         message to.

   304 

   305         data is a string containing the entire full text of the message,

   306         headers (if supplied) and all.  It has been `de-transparencied'

   307         according to RFC 821, Section 4.5.2.  In other words, a line

   308         containing a `.' followed by other text has had the leading dot

   309         removed.

   310 

   311         This function should return None, for a normal `250 Ok' response;

   312         otherwise it returns the desired response string in RFC 821 format.

   313 

   314         """

   315         raise NotImplementedError

   316 

   317 

   318 

   319 class DebuggingServer(SMTPServer):

   320     # Do something with the gathered message

   321     def process_message(self, peer, mailfrom, rcpttos, data):

   322         inheaders = 1

   323         lines = data.split('\n')

   324         print '---------- MESSAGE FOLLOWS ----------'

   325         for line in lines:

   326             # headers first

   327             if inheaders and not line:

   328                 print 'X-Peer:', peer[0]

   329                 inheaders = 0

   330             print line

   331         print '------------ END MESSAGE ------------'

   332 

   333 

   334 

   335 class PureProxy(SMTPServer):

   336     def process_message(self, peer, mailfrom, rcpttos, data):

   337         lines = data.split('\n')

   338         # Look for the last header

   339         i = 0

   340         for line in lines:

   341             if not line:

   342                 break

   343             i += 1

   344         lines.insert(i, 'X-Peer: %s' % peer[0])

   345         data = NEWLINE.join(lines)

   346         refused = self._deliver(mailfrom, rcpttos, data)

   347         # TBD: what to do with refused addresses?

   348         print >> DEBUGSTREAM, 'we got some refusals:', refused

   349 

   350     def _deliver(self, mailfrom, rcpttos, data):

   351         import smtplib

   352         refused = {}

   353         try:

   354             s = smtplib.SMTP()

   355             s.connect(self._remoteaddr[0], self._remoteaddr[1])

   356             try:

   357                 refused = s.sendmail(mailfrom, rcpttos, data)

   358             finally:

   359                 s.quit()

   360         except smtplib.SMTPRecipientsRefused, e:

   361             print >> DEBUGSTREAM, 'got SMTPRecipientsRefused'

   362             refused = e.recipients

   363         except (socket.error, smtplib.SMTPException), e:

   364             print >> DEBUGSTREAM, 'got', e.__class__

   365             # All recipients were refused.  If the exception had an associated

   366             # error code, use it.  Otherwise,fake it with a non-triggering

   367             # exception code.

   368             errcode = getattr(e, 'smtp_code', -1)

   369             errmsg = getattr(e, 'smtp_error', 'ignore')

   370             for r in rcpttos:

   371                 refused[r] = (errcode, errmsg)

   372         return refused

   373 

   374 

   375 

   376 class MailmanProxy(PureProxy):

   377     def process_message(self, peer, mailfrom, rcpttos, data):

   378         from cStringIO import StringIO

   379         from Mailman import Utils

   380         from Mailman import Message

   381         from Mailman import MailList

   382         # If the message is to a Mailman mailing list, then we'll invoke the

   383         # Mailman script directly, without going through the real smtpd.

   384         # Otherwise we'll forward it to the local proxy for disposition.

   385         listnames = []

   386         for rcpt in rcpttos:

   387             local = rcpt.lower().split('@')[0]

   388             # We allow the following variations on the theme

   389             #   listname

   390             #   listname-admin

   391             #   listname-owner

   392             #   listname-request

   393             #   listname-join

   394             #   listname-leave

   395             parts = local.split('-')

   396             if len(parts) > 2:

   397                 continue

   398             listname = parts[0]

   399             if len(parts) == 2:

   400                 command = parts[1]

   401             else:

   402                 command = ''

   403             if not Utils.list_exists(listname) or command not in (

   404                     '', 'admin', 'owner', 'request', 'join', 'leave'):

   405                 continue

   406             listnames.append((rcpt, listname, command))

   407         # Remove all list recipients from rcpttos and forward what we're not

   408         # going to take care of ourselves.  Linear removal should be fine

   409         # since we don't expect a large number of recipients.

   410         for rcpt, listname, command in listnames:

   411             rcpttos.remove(rcpt)

   412         # If there's any non-list destined recipients left,

   413         print >> DEBUGSTREAM, 'forwarding recips:', ' '.join(rcpttos)

   414         if rcpttos:

   415             refused = self._deliver(mailfrom, rcpttos, data)

   416             # TBD: what to do with refused addresses?

   417             print >> DEBUGSTREAM, 'we got refusals:', refused

   418         # Now deliver directly to the list commands

   419         mlists = {}

   420         s = StringIO(data)

   421         msg = Message.Message(s)

   422         # These headers are required for the proper execution of Mailman.  All

   423         # MTAs in existance seem to add these if the original message doesn't

   424         # have them.

   425         if not msg.getheader('from'):

   426             msg['From'] = mailfrom

   427         if not msg.getheader('date'):

   428             msg['Date'] = time.ctime(time.time())

   429         for rcpt, listname, command in listnames:

   430             print >> DEBUGSTREAM, 'sending message to', rcpt

   431             mlist = mlists.get(listname)

   432             if not mlist:

   433                 mlist = MailList.MailList(listname, lock=0)

   434                 mlists[listname] = mlist

   435             # dispatch on the type of command

   436             if command == '':

   437                 # post

   438                 msg.Enqueue(mlist, tolist=1)

   439             elif command == 'admin':

   440                 msg.Enqueue(mlist, toadmin=1)

   441             elif command == 'owner':

   442                 msg.Enqueue(mlist, toowner=1)

   443             elif command == 'request':

   444                 msg.Enqueue(mlist, torequest=1)

   445             elif command in ('join', 'leave'):

   446                 # TBD: this is a hack!

   447                 if command == 'join':

   448                     msg['Subject'] = 'subscribe'

   449                 else:

   450                     msg['Subject'] = 'unsubscribe'

   451                 msg.Enqueue(mlist, torequest=1)

   452 

   453 

   454 

   455 class Options:

   456     setuid = 1

   457     classname = 'PureProxy'

   458 

   459 

   460 

   461 def parseargs():

   462     global DEBUGSTREAM

   463     try:

   464         opts, args = getopt.getopt(

   465             sys.argv[1:], 'nVhc:d',

   466             ['class=', 'nosetuid', 'version', 'help', 'debug'])

   467     except getopt.error, e:

   468         usage(1, e)

   469 

   470     options = Options()

   471     for opt, arg in opts:

   472         if opt in ('-h', '--help'):

   473             usage(0)

   474         elif opt in ('-V', '--version'):

   475             print >> sys.stderr, __version__

   476             sys.exit(0)

   477         elif opt in ('-n', '--nosetuid'):

   478             options.setuid = 0

   479         elif opt in ('-c', '--class'):

   480             options.classname = arg

   481         elif opt in ('-d', '--debug'):

   482             DEBUGSTREAM = sys.stderr

   483 

   484     # parse the rest of the arguments

   485     if len(args) < 1:

   486         localspec = 'localhost:8025'

   487         remotespec = 'localhost:25'

   488     elif len(args) < 2:

   489         localspec = args[0]

   490         remotespec = 'localhost:25'

   491     elif len(args) < 3:

   492         localspec = args[0]

   493         remotespec = args[1]

   494     else:

   495         usage(1, 'Invalid arguments: %s' % COMMASPACE.join(args))

   496 

   497     # split into host/port pairs

   498     i = localspec.find(':')

   499     if i < 0:

   500         usage(1, 'Bad local spec: %s' % localspec)

   501     options.localhost = localspec[:i]

   502     try:

   503         options.localport = int(localspec[i+1:])

   504     except ValueError:

   505         usage(1, 'Bad local port: %s' % localspec)

   506     i = remotespec.find(':')

   507     if i < 0:

   508         usage(1, 'Bad remote spec: %s' % remotespec)

   509     options.remotehost = remotespec[:i]

   510     try:

   511         options.remoteport = int(remotespec[i+1:])

   512     except ValueError:

   513         usage(1, 'Bad remote port: %s' % remotespec)

   514     return options

   515 

   516 

   517 

   518 if __name__ == '__main__':

   519     options = parseargs()

   520     # Become nobody

   521     if options.setuid:

   522         try:

   523             import pwd

   524         except ImportError:

   525             print >> sys.stderr, \

   526                   'Cannot import module "pwd"; try running with -n option.'

   527             sys.exit(1)

   528         nobody = pwd.getpwnam('nobody')[2]

   529         try:

   530             os.setuid(nobody)

   531         except OSError, e:

   532             if e.errno != errno.EPERM: raise

   533             print >> sys.stderr, \

   534                   'Cannot setuid "nobody"; try running with -n option.'

   535             sys.exit(1)

   536     classname = options.classname

   537     if "." in classname:

   538         lastdot = classname.rfind(".")

   539         mod = __import__(classname[:lastdot], globals(), locals(), [""])

   540         classname = classname[lastdot+1:]

   541     else:

   542         import __main__ as mod

   543     class_ = getattr(mod, classname)

   544     proxy = class_((options.localhost, options.localport),

   545                    (options.remotehost, options.remoteport))

   546     try:

   547         asyncore.loop()

   548     except KeyboardInterrupt:

   549         pass