Home | History | Annotate | Download | only in bin
      1 #!/tmp/ndk-andrewhsieh/buildhost/install/prebuilt/linux-x86/bin/python2.7
      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 # Overview:
     39 #
     40 # This file implements the minimal SMTP protocol as defined in RFC 821.  It
     41 # has a hierarchy of classes which implement the backend functionality for the
     42 # smtpd.  A number of classes are provided:
     43 #
     44 #   SMTPServer - the base class for the backend.  Raises NotImplementedError
     45 #   if you try to use it.
     46 #
     47 #   DebuggingServer - simply prints each message it receives on stdout.
     48 #
     49 #   PureProxy - Proxies all messages to a real smtpd which does final
     50 #   delivery.  One known problem with this class is that it doesn't handle
     51 #   SMTP errors from the backend server at all.  This should be fixed
     52 #   (contributions are welcome!).
     53 #
     54 #   MailmanProxy - An experimental hack to work with GNU Mailman
     55 #   <www.list.org>.  Using this server as your real incoming smtpd, your
     56 #   mailhost will automatically recognize and accept mail destined to Mailman
     57 #   lists when those lists are created.  Every message not destined for a list
     58 #   gets forwarded to a real backend smtpd, as with PureProxy.  Again, errors
     59 #   are not handled correctly yet.
     60 #
     61 # Please note that this script requires Python 2.0
     62 #
     63 # Author: Barry Warsaw <barry (at] python.org>
     64 #
     65 # TODO:
     66 #
     67 # - support mailbox delivery
     68 # - alias files
     69 # - ESMTP
     70 # - handle error codes from the backend smtpd
     71 
     72 import sys
     73 import os
     74 import errno
     75 import getopt
     76 import time
     77 import socket
     78 import asyncore
     79 import asynchat
     80 
     81 __all__ = ["SMTPServer","DebuggingServer","PureProxy","MailmanProxy"]
     82 
     83 program = sys.argv[0]
     84 __version__ = 'Python SMTP proxy version 0.2'
     85 
     86 
     87 class Devnull:
     88     def write(self, msg): pass
     89     def flush(self): pass
     90 
     91 
     92 DEBUGSTREAM = Devnull()
     93 NEWLINE = '\n'
     94 EMPTYSTRING = ''
     95 COMMASPACE = ', '
     96 
     97 
     98 def usage(code, msg=''):
     99     print >> sys.stderr, __doc__ % globals()
    100     if msg:
    101         print >> sys.stderr, msg
    102     sys.exit(code)
    103 
    104 
    105 class SMTPChannel(asynchat.async_chat):
    106     COMMAND = 0
    107     DATA = 1
    108 
    109     def __init__(self, server, conn, addr):
    110         asynchat.async_chat.__init__(self, conn)
    111         self.__server = server
    112         self.__conn = conn
    113         self.__addr = addr
    114         self.__line = []
    115         self.__state = self.COMMAND
    116         self.__greeting = 0
    117         self.__mailfrom = None
    118         self.__rcpttos = []
    119         self.__data = ''
    120         self.__fqdn = socket.getfqdn()
    121         try:
    122             self.__peer = conn.getpeername()
    123         except socket.error, err:
    124             # a race condition  may occur if the other end is closing
    125             # before we can get the peername
    126             self.close()
    127             if err[0] != errno.ENOTCONN:
    128                 raise
    129             return
    130         print >> DEBUGSTREAM, 'Peer:', repr(self.__peer)
    131         self.push('220 %s %s' % (self.__fqdn, __version__))
    132         self.set_terminator('\r\n')
    133 
    134     # Overrides base class for convenience
    135     def push(self, msg):
    136         asynchat.async_chat.push(self, msg + '\r\n')
    137 
    138     # Implementation of base class abstract method
    139     def collect_incoming_data(self, data):
    140         self.__line.append(data)
    141 
    142     # Implementation of base class abstract method
    143     def found_terminator(self):
    144         line = EMPTYSTRING.join(self.__line)
    145         print >> DEBUGSTREAM, 'Data:', repr(line)
    146         self.__line = []
    147         if self.__state == self.COMMAND:
    148             if not line:
    149                 self.push('500 Error: bad syntax')
    150                 return
    151             method = None
    152             i = line.find(' ')
    153             if i < 0:
    154                 command = line.upper()
    155                 arg = None
    156             else:
    157                 command = line[:i].upper()
    158                 arg = line[i+1:].strip()
    159             method = getattr(self, 'smtp_' + command, None)
    160             if not method:
    161                 self.push('502 Error: command "%s" not implemented' % command)
    162                 return
    163             method(arg)
    164             return
    165         else:
    166             if self.__state != self.DATA:
    167                 self.push('451 Internal confusion')
    168                 return
    169             # Remove extraneous carriage returns and de-transparency according
    170             # to RFC 821, Section 4.5.2.
    171             data = []
    172             for text in line.split('\r\n'):
    173                 if text and text[0] == '.':
    174                     data.append(text[1:])
    175                 else:
    176                     data.append(text)
    177             self.__data = NEWLINE.join(data)
    178             status = self.__server.process_message(self.__peer,
    179                                                    self.__mailfrom,
    180                                                    self.__rcpttos,
    181                                                    self.__data)
    182             self.__rcpttos = []
    183             self.__mailfrom = None
    184             self.__state = self.COMMAND
    185             self.set_terminator('\r\n')
    186             if not status:
    187                 self.push('250 Ok')
    188             else:
    189                 self.push(status)
    190 
    191     # SMTP and ESMTP commands
    192     def smtp_HELO(self, arg):
    193         if not arg:
    194             self.push('501 Syntax: HELO hostname')
    195             return
    196         if self.__greeting:
    197             self.push('503 Duplicate HELO/EHLO')
    198         else:
    199             self.__greeting = arg
    200             self.push('250 %s' % self.__fqdn)
    201 
    202     def smtp_NOOP(self, arg):
    203         if arg:
    204             self.push('501 Syntax: NOOP')
    205         else:
    206             self.push('250 Ok')
    207 
    208     def smtp_QUIT(self, arg):
    209         # args is ignored
    210         self.push('221 Bye')
    211         self.close_when_done()
    212 
    213     # factored
    214     def __getaddr(self, keyword, arg):
    215         address = None
    216         keylen = len(keyword)
    217         if arg[:keylen].upper() == keyword:
    218             address = arg[keylen:].strip()
    219             if not address:
    220                 pass
    221             elif address[0] == '<' and address[-1] == '>' and address != '<>':
    222                 # Addresses can be in the form <person (at] dom.com> but watch out
    223                 # for null address, e.g. <>
    224                 address = address[1:-1]
    225         return address
    226 
    227     def smtp_MAIL(self, arg):
    228         print >> DEBUGSTREAM, '===> MAIL', arg
    229         address = self.__getaddr('FROM:', arg) if arg else None
    230         if not address:
    231             self.push('501 Syntax: MAIL FROM:<address>')
    232             return
    233         if self.__mailfrom:
    234             self.push('503 Error: nested MAIL command')
    235             return
    236         self.__mailfrom = address
    237         print >> DEBUGSTREAM, 'sender:', self.__mailfrom
    238         self.push('250 Ok')
    239 
    240     def smtp_RCPT(self, arg):
    241         print >> DEBUGSTREAM, '===> RCPT', arg
    242         if not self.__mailfrom:
    243             self.push('503 Error: need MAIL command')
    244             return
    245         address = self.__getaddr('TO:', arg) if arg else None
    246         if not address:
    247             self.push('501 Syntax: RCPT TO: <address>')
    248             return
    249         self.__rcpttos.append(address)
    250         print >> DEBUGSTREAM, 'recips:', self.__rcpttos
    251         self.push('250 Ok')
    252 
    253     def smtp_RSET(self, arg):
    254         if arg:
    255             self.push('501 Syntax: RSET')
    256             return
    257         # Resets the sender, recipients, and data, but not the greeting
    258         self.__mailfrom = None
    259         self.__rcpttos = []
    260         self.__data = ''
    261         self.__state = self.COMMAND
    262         self.push('250 Ok')
    263 
    264     def smtp_DATA(self, arg):
    265         if not self.__rcpttos:
    266             self.push('503 Error: need RCPT command')
    267             return
    268         if arg:
    269             self.push('501 Syntax: DATA')
    270             return
    271         self.__state = self.DATA
    272         self.set_terminator('\r\n.\r\n')
    273         self.push('354 End data with <CR><LF>.<CR><LF>')
    274 
    275 
    276 class SMTPServer(asyncore.dispatcher):
    277     def __init__(self, localaddr, remoteaddr):
    278         self._localaddr = localaddr
    279         self._remoteaddr = remoteaddr
    280         asyncore.dispatcher.__init__(self)
    281         try:
    282             self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
    283             # try to re-use a server port if possible
    284             self.set_reuse_addr()
    285             self.bind(localaddr)
    286             self.listen(5)
    287         except:
    288             # cleanup asyncore.socket_map before raising
    289             self.close()
    290             raise
    291         else:
    292             print >> DEBUGSTREAM, \
    293                   '%s started at %s\n\tLocal addr: %s\n\tRemote addr:%s' % (
    294                 self.__class__.__name__, time.ctime(time.time()),
    295                 localaddr, remoteaddr)
    296 
    297     def handle_accept(self):
    298         pair = self.accept()
    299         if pair is not None:
    300             conn, addr = pair
    301             print >> DEBUGSTREAM, 'Incoming connection from %s' % repr(addr)
    302             channel = SMTPChannel(self, conn, addr)
    303 
    304     # API for "doing something useful with the message"
    305     def process_message(self, peer, mailfrom, rcpttos, data):
    306         """Override this abstract method to handle messages from the client.
    307 
    308         peer is a tuple containing (ipaddr, port) of the client that made the
    309         socket connection to our smtp port.
    310 
    311         mailfrom is the raw address the client claims the message is coming
    312         from.
    313 
    314         rcpttos is a list of raw addresses the client wishes to deliver the
    315         message to.
    316 
    317         data is a string containing the entire full text of the message,
    318         headers (if supplied) and all.  It has been `de-transparencied'
    319         according to RFC 821, Section 4.5.2.  In other words, a line
    320         containing a `.' followed by other text has had the leading dot
    321         removed.
    322 
    323         This function should return None, for a normal `250 Ok' response;
    324         otherwise it returns the desired response string in RFC 821 format.
    325 
    326         """
    327         raise NotImplementedError
    328 
    329 
    330 class DebuggingServer(SMTPServer):
    331     # Do something with the gathered message
    332     def process_message(self, peer, mailfrom, rcpttos, data):
    333         inheaders = 1
    334         lines = data.split('\n')
    335         print '---------- MESSAGE FOLLOWS ----------'
    336         for line in lines:
    337             # headers first
    338             if inheaders and not line:
    339                 print 'X-Peer:', peer[0]
    340                 inheaders = 0
    341             print line
    342         print '------------ END MESSAGE ------------'
    343 
    344 
    345 class PureProxy(SMTPServer):
    346     def process_message(self, peer, mailfrom, rcpttos, data):
    347         lines = data.split('\n')
    348         # Look for the last header
    349         i = 0
    350         for line in lines:
    351             if not line:
    352                 break
    353             i += 1
    354         lines.insert(i, 'X-Peer: %s' % peer[0])
    355         data = NEWLINE.join(lines)
    356         refused = self._deliver(mailfrom, rcpttos, data)
    357         # TBD: what to do with refused addresses?
    358         print >> DEBUGSTREAM, 'we got some refusals:', refused
    359 
    360     def _deliver(self, mailfrom, rcpttos, data):
    361         import smtplib
    362         refused = {}
    363         try:
    364             s = smtplib.SMTP()
    365             s.connect(self._remoteaddr[0], self._remoteaddr[1])
    366             try:
    367                 refused = s.sendmail(mailfrom, rcpttos, data)
    368             finally:
    369                 s.quit()
    370         except smtplib.SMTPRecipientsRefused, e:
    371             print >> DEBUGSTREAM, 'got SMTPRecipientsRefused'
    372             refused = e.recipients
    373         except (socket.error, smtplib.SMTPException), e:
    374             print >> DEBUGSTREAM, 'got', e.__class__
    375             # All recipients were refused.  If the exception had an associated
    376             # error code, use it.  Otherwise,fake it with a non-triggering
    377             # exception code.
    378             errcode = getattr(e, 'smtp_code', -1)
    379             errmsg = getattr(e, 'smtp_error', 'ignore')
    380             for r in rcpttos:
    381                 refused[r] = (errcode, errmsg)
    382         return refused
    383 
    384 
    385 class MailmanProxy(PureProxy):
    386     def process_message(self, peer, mailfrom, rcpttos, data):
    387         from cStringIO import StringIO
    388         from Mailman import Utils
    389         from Mailman import Message
    390         from Mailman import MailList
    391         # If the message is to a Mailman mailing list, then we'll invoke the
    392         # Mailman script directly, without going through the real smtpd.
    393         # Otherwise we'll forward it to the local proxy for disposition.
    394         listnames = []
    395         for rcpt in rcpttos:
    396             local = rcpt.lower().split('@')[0]
    397             # We allow the following variations on the theme
    398             #   listname
    399             #   listname-admin
    400             #   listname-owner
    401             #   listname-request
    402             #   listname-join
    403             #   listname-leave
    404             parts = local.split('-')
    405             if len(parts) > 2:
    406                 continue
    407             listname = parts[0]
    408             if len(parts) == 2:
    409                 command = parts[1]
    410             else:
    411                 command = ''
    412             if not Utils.list_exists(listname) or command not in (
    413                     '', 'admin', 'owner', 'request', 'join', 'leave'):
    414                 continue
    415             listnames.append((rcpt, listname, command))
    416         # Remove all list recipients from rcpttos and forward what we're not
    417         # going to take care of ourselves.  Linear removal should be fine
    418         # since we don't expect a large number of recipients.
    419         for rcpt, listname, command in listnames:
    420             rcpttos.remove(rcpt)
    421         # If there's any non-list destined recipients left,
    422         print >> DEBUGSTREAM, 'forwarding recips:', ' '.join(rcpttos)
    423         if rcpttos:
    424             refused = self._deliver(mailfrom, rcpttos, data)
    425             # TBD: what to do with refused addresses?
    426             print >> DEBUGSTREAM, 'we got refusals:', refused
    427         # Now deliver directly to the list commands
    428         mlists = {}
    429         s = StringIO(data)
    430         msg = Message.Message(s)
    431         # These headers are required for the proper execution of Mailman.  All
    432         # MTAs in existence seem to add these if the original message doesn't
    433         # have them.
    434         if not msg.getheader('from'):
    435             msg['From'] = mailfrom
    436         if not msg.getheader('date'):
    437             msg['Date'] = time.ctime(time.time())
    438         for rcpt, listname, command in listnames:
    439             print >> DEBUGSTREAM, 'sending message to', rcpt
    440             mlist = mlists.get(listname)
    441             if not mlist:
    442                 mlist = MailList.MailList(listname, lock=0)
    443                 mlists[listname] = mlist
    444             # dispatch on the type of command
    445             if command == '':
    446                 # post
    447                 msg.Enqueue(mlist, tolist=1)
    448             elif command == 'admin':
    449                 msg.Enqueue(mlist, toadmin=1)
    450             elif command == 'owner':
    451                 msg.Enqueue(mlist, toowner=1)
    452             elif command == 'request':
    453                 msg.Enqueue(mlist, torequest=1)
    454             elif command in ('join', 'leave'):
    455                 # TBD: this is a hack!
    456                 if command == 'join':
    457                     msg['Subject'] = 'subscribe'
    458                 else:
    459                     msg['Subject'] = 'unsubscribe'
    460                 msg.Enqueue(mlist, torequest=1)
    461 
    462 
    463 class Options:
    464     setuid = 1
    465     classname = 'PureProxy'
    466 
    467 
    468 def parseargs():
    469     global DEBUGSTREAM
    470     try:
    471         opts, args = getopt.getopt(
    472             sys.argv[1:], 'nVhc:d',
    473             ['class=', 'nosetuid', 'version', 'help', 'debug'])
    474     except getopt.error, e:
    475         usage(1, e)
    476 
    477     options = Options()
    478     for opt, arg in opts:
    479         if opt in ('-h', '--help'):
    480             usage(0)
    481         elif opt in ('-V', '--version'):
    482             print >> sys.stderr, __version__
    483             sys.exit(0)
    484         elif opt in ('-n', '--nosetuid'):
    485             options.setuid = 0
    486         elif opt in ('-c', '--class'):
    487             options.classname = arg
    488         elif opt in ('-d', '--debug'):
    489             DEBUGSTREAM = sys.stderr
    490 
    491     # parse the rest of the arguments
    492     if len(args) < 1:
    493         localspec = 'localhost:8025'
    494         remotespec = 'localhost:25'
    495     elif len(args) < 2:
    496         localspec = args[0]
    497         remotespec = 'localhost:25'
    498     elif len(args) < 3:
    499         localspec = args[0]
    500         remotespec = args[1]
    501     else:
    502         usage(1, 'Invalid arguments: %s' % COMMASPACE.join(args))
    503 
    504     # split into host/port pairs
    505     i = localspec.find(':')
    506     if i < 0:
    507         usage(1, 'Bad local spec: %s' % localspec)
    508     options.localhost = localspec[:i]
    509     try:
    510         options.localport = int(localspec[i+1:])
    511     except ValueError:
    512         usage(1, 'Bad local port: %s' % localspec)
    513     i = remotespec.find(':')
    514     if i < 0:
    515         usage(1, 'Bad remote spec: %s' % remotespec)
    516     options.remotehost = remotespec[:i]
    517     try:
    518         options.remoteport = int(remotespec[i+1:])
    519     except ValueError:
    520         usage(1, 'Bad remote port: %s' % remotespec)
    521     return options
    522 
    523 
    524 if __name__ == '__main__':
    525     options = parseargs()
    526     # Become nobody
    527     classname = options.classname
    528     if "." in classname:
    529         lastdot = classname.rfind(".")
    530         mod = __import__(classname[:lastdot], globals(), locals(), [""])
    531         classname = classname[lastdot+1:]
    532     else:
    533         import __main__ as mod
    534     class_ = getattr(mod, classname)
    535     proxy = class_((options.localhost, options.localport),
    536                    (options.remotehost, options.remoteport))
    537     if options.setuid:
    538         try:
    539             import pwd
    540         except ImportError:
    541             print >> sys.stderr, \
    542                   'Cannot import module "pwd"; try running with -n option.'
    543             sys.exit(1)
    544         nobody = pwd.getpwnam('nobody')[2]
    545         try:
    546             os.setuid(nobody)
    547         except OSError, e:
    548             if e.errno != errno.EPERM: raise
    549             print >> sys.stderr, \
    550                   'Cannot setuid "nobody"; try running with -n option.'
    551             sys.exit(1)
    552     try:
    553         asyncore.loop()
    554     except KeyboardInterrupt:
    555         pass
    556