| # -*- coding: utf-8 -*- |
| # |
| # Copyright (C) 2005-2009 Edgewall Software |
| # Copyright (C) 2005-2006 Emmanuel Blot <emmanuel.blot@free.fr> |
| # All rights reserved. |
| # |
| # This software is licensed as described in the file COPYING, which |
| # you should have received as part of this distribution. The terms |
| # are also available at http://trac.edgewall.org/wiki/TracLicense. |
| # |
| # This software consists of voluntary contributions made by many |
| # individuals. For the exact contribution history, see the revision |
| # history and logs, available at http://trac.edgewall.org/log/. |
| # |
| # Include a basic SMTP server, based on L. Smithson |
| # (lsmithson@open-networks.co.uk) extensible Python SMTP Server |
| # |
| # This file does not contain unit tests, but provides a set of |
| # classes to run SMTP notification tests |
| # |
| |
| import socket |
| import string |
| import threading |
| import re |
| import base64 |
| import quopri |
| |
| |
| LF = '\n' |
| CR = '\r' |
| email_re = re.compile(r"([\w\d_\.\-])+\@(([\w\d\-])+\.)+([\w\d]{2,4})+") |
| header_re = re.compile(r'^=\?(?P<charset>[\w\d\-]+)\?(?P<code>[qb])\?(?P<value>.*)\?=$') |
| |
| |
| class SMTPServerInterface: |
| """ |
| A base class for the imlementation of an application specific SMTP |
| Server. Applications should subclass this and overide these |
| methods, which by default do nothing. |
| |
| A method is defined for each RFC821 command. For each of these |
| methods, 'args' is the complete command received from the |
| client. The 'data' method is called after all of the client DATA |
| is received. |
| |
| If a method returns 'None', then a '250 OK'message is |
| automatically sent to the client. If a subclass returns a non-null |
| string then it is returned instead. |
| """ |
| |
| def helo(self, args): |
| return None |
| |
| def mail_from(self, args): |
| return None |
| |
| def rcpt_to(self, args): |
| return None |
| |
| def data(self, args): |
| return None |
| |
| def quit(self, args): |
| return None |
| |
| def reset(self, args): |
| return None |
| |
| # |
| # Some helper functions for manipulating from & to addresses etc. |
| # |
| |
| def strip_address(address): |
| """ |
| Strip the leading & trailing <> from an address. Handy for |
| getting FROM: addresses. |
| """ |
| start = string.index(address, '<') + 1 |
| end = string.index(address, '>') |
| return address[start:end] |
| |
| def split_to(address): |
| """ |
| Return 'address' as undressed (host, fulladdress) tuple. |
| Handy for use with TO: addresses. |
| """ |
| start = string.index(address, '<') + 1 |
| sep = string.index(address, '@') + 1 |
| end = string.index(address, '>') |
| return (address[sep:end], address[start:end],) |
| |
| |
| # |
| # This drives the state for a single RFC821 message. |
| # |
| class SMTPServerEngine: |
| """ |
| Server engine that calls methods on the SMTPServerInterface object |
| passed at construction time. It is constructed with a bound socket |
| connection to a client. The 'chug' method drives the state, |
| returning when the client RFC821 transaction is complete. |
| """ |
| |
| ST_INIT = 0 |
| ST_HELO = 1 |
| ST_MAIL = 2 |
| ST_RCPT = 3 |
| ST_DATA = 4 |
| ST_QUIT = 5 |
| |
| def __init__(self, socket, impl): |
| self.impl = impl |
| self.socket = socket |
| self.state = SMTPServerEngine.ST_INIT |
| |
| def chug(self): |
| """ |
| Chug the engine, till QUIT is received from the client. As |
| each RFC821 message is received, calls are made on the |
| SMTPServerInterface methods on the object passed at |
| construction time. |
| """ |
| self.socket.send("220 Welcome to Trac notification test server\r\n") |
| while 1: |
| data = '' |
| completeLine = 0 |
| # Make sure an entire line is received before handing off |
| # to the state engine. Thanks to John Hall for pointing |
| # this out. |
| while not completeLine: |
| try: |
| lump = self.socket.recv(1024) |
| if len(lump): |
| data += lump |
| if (len(data) >= 2) and data[-2:] == '\r\n': |
| completeLine = 1 |
| if self.state != SMTPServerEngine.ST_DATA: |
| rsp, keep = self.do_command(data) |
| else: |
| rsp = self.do_data(data) |
| if rsp == None: |
| continue |
| self.socket.send(rsp + "\r\n") |
| if keep == 0: |
| self.socket.close() |
| return |
| else: |
| # EOF |
| return |
| except socket.error: |
| return |
| |
| def do_command(self, data): |
| """Process a single SMTP Command""" |
| cmd = data[0:4] |
| cmd = string.upper(cmd) |
| keep = 1 |
| rv = None |
| if cmd == "HELO": |
| self.state = SMTPServerEngine.ST_HELO |
| rv = self.impl.helo(data[5:]) |
| elif cmd == "RSET": |
| rv = self.impl.reset(data[5:]) |
| self.data_accum = "" |
| self.state = SMTPServerEngine.ST_INIT |
| elif cmd == "NOOP": |
| pass |
| elif cmd == "QUIT": |
| rv = self.impl.quit(data[5:]) |
| keep = 0 |
| elif cmd == "MAIL": |
| if self.state != SMTPServerEngine.ST_HELO: |
| return ("503 Bad command sequence", 1) |
| self.state = SMTPServerEngine.ST_MAIL |
| rv = self.impl.mail_from(data[5:]) |
| elif cmd == "RCPT": |
| if (self.state != SMTPServerEngine.ST_MAIL) and \ |
| (self.state != SMTPServerEngine.ST_RCPT): |
| return ("503 Bad command sequence", 1) |
| self.state = SMTPServerEngine.ST_RCPT |
| rv = self.impl.rcpt_to(data[5:]) |
| elif cmd == "DATA": |
| if self.state != SMTPServerEngine.ST_RCPT: |
| return ("503 Bad command sequence", 1) |
| self.state = SMTPServerEngine.ST_DATA |
| self.data_accum = "" |
| return ("354 OK, Enter data, terminated with a \\r\\n.\\r\\n", 1) |
| else: |
| return ("505 Eh? WTF was that?", 1) |
| |
| if rv: |
| return (rv, keep) |
| else: |
| return("250 OK", keep) |
| |
| def do_data(self, data): |
| """ |
| Process SMTP Data. Accumulates client DATA until the |
| terminator is found. |
| """ |
| self.data_accum = self.data_accum + data |
| if len(self.data_accum) > 4 and self.data_accum[-5:] == '\r\n.\r\n': |
| self.data_accum = self.data_accum[:-5] |
| rv = self.impl.data(self.data_accum) |
| self.state = SMTPServerEngine.ST_HELO |
| if rv: |
| return rv |
| else: |
| return "250 OK - Data and terminator. found" |
| else: |
| return None |
| |
| |
| class SMTPServer: |
| """ |
| A single threaded SMTP Server connection manager. Listens for |
| incoming SMTP connections on a given port. For each connection, |
| the SMTPServerEngine is chugged, passing the given instance of |
| SMTPServerInterface. |
| """ |
| |
| def __init__(self, port): |
| self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) |
| self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) |
| self._socket.bind(("127.0.0.1", port)) |
| self._socket_service = None |
| |
| def serve(self, impl): |
| while ( self._resume ): |
| try: |
| nsd = self._socket.accept() |
| except socket.error: |
| return |
| self._socket_service = nsd[0] |
| engine = SMTPServerEngine(self._socket_service, impl) |
| engine.chug() |
| self._socket_service = None |
| |
| def start(self): |
| self._socket.listen(1) |
| self._resume = True |
| |
| def stop(self): |
| self._resume = False |
| |
| def terminate(self): |
| if self._socket_service: |
| # force the blocking socket to stop waiting for data |
| try: |
| #self._socket_service.shutdown(2) |
| self._socket_service.close() |
| except AttributeError: |
| # the SMTP server may also discard the socket |
| pass |
| self._socket_service = None |
| if self._socket: |
| #self._socket.shutdown(2) |
| self._socket.close() |
| self._socket = None |
| |
| |
| class SMTPServerStore(SMTPServerInterface): |
| """ |
| Simple store for SMTP data |
| """ |
| |
| def __init__(self): |
| self.reset(None) |
| |
| def helo(self, args): |
| self.reset(None) |
| |
| def mail_from(self, args): |
| if args.lower().startswith('from:'): |
| self.sender = strip_address(args[5:].replace('\r\n','').strip()) |
| |
| def rcpt_to(self, args): |
| if args.lower().startswith('to:'): |
| rcpt = args[3:].replace('\r\n','').strip() |
| self.recipients.append(strip_address(rcpt)) |
| |
| def data(self, args): |
| self.message = args |
| |
| def quit(self, args): |
| pass |
| |
| def reset(self, args): |
| self.sender = None |
| self.recipients = [] |
| self.message = None |
| |
| |
| class SMTPThreadedServer(threading.Thread): |
| """ |
| Run a SMTP server for a single connection, within a dedicated thread |
| """ |
| |
| def __init__(self, port): |
| self.port = port |
| self.server = SMTPServer(port) |
| self.store = SMTPServerStore() |
| threading.Thread.__init__(self) |
| |
| def run(self): |
| # run from within the SMTP server thread |
| self.server.serve(impl = self.store) |
| |
| def start(self): |
| # run from the main thread |
| self.server.start() |
| threading.Thread.start(self) |
| |
| def stop(self): |
| # run from the main thread |
| self.server.stop() |
| # send a message to make the SMTP server quit gracefully |
| s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) |
| try: |
| s.connect(('127.0.0.1', self.port)) |
| r = s.send("QUIT\r\n") |
| except socket.error: |
| pass |
| s.close() |
| # wait for the SMTP server to complete (for up to 2 secs) |
| self.join(2.0) |
| # clean up the SMTP server (and force quit if needed) |
| self.server.terminate() |
| |
| def get_sender(self): |
| return self.store.sender |
| |
| def get_recipients(self): |
| return self.store.recipients |
| |
| def get_message(self): |
| return self.store.message |
| |
| def cleanup(self): |
| self.store.reset(None) |
| |
| |
| def smtp_address(fulladdr): |
| mo = email_re.search(fulladdr) |
| if mo: |
| return mo.group(0) |
| if start >= 0: |
| return fulladdr[start+1:-1] |
| return fulladdr |
| |
| |
| def decode_header(header): |
| """ Decode a MIME-encoded header value """ |
| mo = header_re.match(header) |
| # header does not seem to be MIME-encoded |
| if not mo: |
| return header |
| # attempts to decode the hedear, |
| # following the specified MIME endoding and charset |
| try: |
| encoding = mo.group('code').lower() |
| if encoding == 'q': |
| val = quopri.decodestring(mo.group('value'), header=True) |
| elif encoding == 'b': |
| val = base64.decodestring(mo.group('value')) |
| else: |
| raise AssertionError, "unsupported encoding: %s" % encoding |
| header = unicode(val, mo.group('charset')) |
| except Exception, e: |
| raise AssertionError, e |
| return header |
| |
| |
| def parse_smtp_message(msg): |
| """ Split a SMTP message into its headers and body. |
| Returns a (headers, body) tuple |
| We do not use the email/MIME Python facilities here |
| as they may accept invalid RFC822 data, or data we do not |
| want to support nor generate """ |
| headers = {} |
| lh = None |
| body = None |
| # last line does not contain the final line ending |
| msg += '\r\n' |
| for line in msg.splitlines(True): |
| if body != None: |
| # append current line to the body |
| if line[-2] == CR: |
| body += line[0:-2] |
| body += '\n' |
| else: |
| raise AssertionError, "body misses CRLF: %s (0x%x)" \ |
| % (line, ord(line[-1])) |
| else: |
| if line[-2] != CR: |
| # RFC822 requires CRLF at end of field line |
| raise AssertionError, "header field misses CRLF: %s (0x%x)" \ |
| % (line, ord(line[-1])) |
| # discards CR |
| line = line[0:-2] |
| if line.strip() == '': |
| # end of headers, body starts |
| body = '' |
| else: |
| val = None |
| if line[0] in ' \t': |
| # continution of the previous line |
| if not lh: |
| # unexpected multiline |
| raise AssertionError, \ |
| "unexpected folded line: %s" % line |
| val = decode_header(line.strip(' \t')) |
| # appends the current line to the previous one |
| if not isinstance(headers[lh], tuple): |
| headers[lh] += val |
| else: |
| headers[lh][-1] = headers[lh][-1] + val |
| else: |
| # splits header name from value |
| (h, v) = line.split(':', 1) |
| val = decode_header(v.strip()) |
| if headers.has_key(h): |
| if isinstance(headers[h], tuple): |
| headers[h] += val |
| else: |
| headers[h] = (headers[h], val) |
| else: |
| headers[h] = val |
| # stores the last header (for multilines headers) |
| lh = h |
| # returns the headers and the message body |
| return (headers, body) |
