def test_parse_string(self): ext = Extensions() header = ext.parse_string("""\ the header EXT1 PARSETEST DATA""") self.assertEqual('the header', header) self.assertTrue('EXT1' in ext) self.assertTrue('PARSETEST' in ext) self.assertEqual(None, ext.getparam('EXT1')) self.assertEqual('DATA', ext.getparam('PARSETEST'))
def test_parse_string(self): ext = Extensions() header = ext.parse_string( """\ the header EXT1 PARSETEST DATA""" ) self.assertEqual("the header", header) self.assertTrue("EXT1" in ext) self.assertTrue("PARSETEST" in ext) self.assertEqual(None, ext.getparam("EXT1")) self.assertEqual("DATA", ext.getparam("PARSETEST"))
class TestSmtpExtensions(unittest.TestCase): def setUp(self): self.ext = Extensions() self.ext.extensions = {'EMPTY': None, 'TEST': 'STUFF'} def test_contains(self): self.assertTrue('TEST' in self.ext) self.assertTrue('test' in self.ext) self.assertFalse('BAD' in self.ext) def test_reset(self): self.assertTrue('TEST' in self.ext) self.ext.reset() self.assertFalse('TEST' in self.ext) def test_add(self): self.ext.add('new') self.assertTrue('NEW' in self.ext) def test_drop(self): self.assertTrue(self.ext.drop('test')) self.assertFalse('TEST' in self.ext) self.assertFalse(self.ext.drop('BAD')) def test_getparam(self): self.assertEqual(None, self.ext.getparam('BAD')) self.assertEqual(None, self.ext.getparam('EMPTY')) self.assertEqual('STUFF', self.ext.getparam('TEST')) def test_getparam_filter(self): ret = self.ext.getparam('TEST', lambda x: x.strip('F')) self.assertEqual('STU', ret) ret = self.ext.getparam('EMPTY', lambda x: x) self.assertEqual(None, ret) def test_getparam_filter_valueerror(self): self.assertEqual(None, self.ext.getparam('TEST', int)) def test_parse_string(self): ext = Extensions() header = ext.parse_string("""\ the header EXT1 PARSETEST DATA""") self.assertEqual('the header', header) self.assertTrue('EXT1' in ext) self.assertTrue('PARSETEST' in ext) self.assertEqual(None, ext.getparam('EXT1')) self.assertEqual('DATA', ext.getparam('PARSETEST')) def test_build_string(self): possibilities = ("""\ the header EMPTY TEST STUFF""", """\ the header TEST STUFF EMPTY""") ret = self.ext.build_string('the header').replace('\r', '') self.assertTrue(ret in possibilities) def test_build_string_valueerror(self): class MyExtension(object): def __init__(self): pass def __str__(self): raise ValueError('test') ext = Extensions() ext.extensions = {'ONE': 'OK VALUE', 'TWO': MyExtension()} expected = """the header\r\nONE OK VALUE""" self.assertEqual(expected, ext.build_string('the header'))
class Server(object): """Class that implements an SMTP server given a connected socket. This object has an ``extensions`` attribute that is an |Extensions| object that contains the SMTP extensions the server supports. :param socket: Connected socket for the session. :type socket: :class:`gevent.socket.socket` :param handlers: Object with methods that will be called when corresponding SMTP commands are received. These methods can modify the |Reply| before the command response is sent. :param auth_class: Optional |Auth| sub-class to enable authentication. :param tls: Optional dictionary of TLS settings passed directly as keyword arguments to :class:`gevent.ssl.SSLSocket`. :param tls_immediately: If True, the socket will be encrypted immediately. :param tls_wrapper: Optional function that takes a socket and the ``tls`` dictionary, creates a new encrypted socket, performs the TLS handshake, and returns it. The default uses :class:`~gevent.ssl.SSLSocket`. :type tls_immediately: True or False :param command_timeout: Optional timeout waiting for a command to be sent from the client. :param data_timeout: Optional timeout waiting for data to be sent from the client. """ def __init__(self, socket, handlers, auth_class=None, tls=None, tls_immediately=False, tls_wrapper=None, command_timeout=None, data_timeout=None): self.handlers = handlers self.extensions = Extensions() self.have_mailfrom = None self.have_rcptto = None self.ehlo_as = None self.auth_result = None self.encrypted = False self.extensions.add('8BITMIME') self.extensions.add('PIPELINING') self.extensions.add('ENHANCEDSTATUSCODES') if tls and not tls_immediately: self.extensions.add('STARTTLS') if auth_class: self.extensions.add('AUTH', auth_class(self)) self.io = IO(socket, tls_wrapper) if tls: self.tls = tls.copy() self.tls.setdefault('server_side', True) else: self.tls = None self.tls_immediately = tls_immediately self.command_timeout = command_timeout self.data_timeout = data_timeout or command_timeout def _recv_command(self): timeout = Timeout(self.command_timeout) timeout.start() try: return self.io.recv_command() finally: timeout.cancel() def _get_message_data(self): max_size = self.extensions.getparam('SIZE', filter=int) reader = DataReader(self.io, max_size) err = None timeout = Timeout(self.data_timeout) timeout.start() try: data = reader.recv() except ConnectionLost: raise except SmtpError, e: data = None err = e finally:
class TestSmtpExtensions(unittest.TestCase): def setUp(self): self.ext = Extensions() self.ext.extensions = {"EMPTY": None, "TEST": "STUFF"} def test_contains(self): self.assertTrue("TEST" in self.ext) self.assertTrue("test" in self.ext) self.assertFalse("BAD" in self.ext) def test_reset(self): self.assertTrue("TEST" in self.ext) self.ext.reset() self.assertFalse("TEST" in self.ext) def test_add(self): self.ext.add("new") self.assertTrue("NEW" in self.ext) def test_drop(self): self.assertTrue(self.ext.drop("test")) self.assertFalse("TEST" in self.ext) self.assertFalse(self.ext.drop("BAD")) def test_getparam(self): self.assertEqual(None, self.ext.getparam("BAD")) self.assertEqual(None, self.ext.getparam("EMPTY")) self.assertEqual("STUFF", self.ext.getparam("TEST")) def test_getparam_filter(self): ret = self.ext.getparam("TEST", lambda x: x.strip("F")) self.assertEqual("STU", ret) ret = self.ext.getparam("EMPTY", lambda x: x) self.assertEqual(None, ret) def test_getparam_filter_valueerror(self): self.assertEqual(None, self.ext.getparam("TEST", int)) def test_parse_string(self): ext = Extensions() header = ext.parse_string( """\ the header EXT1 PARSETEST DATA""" ) self.assertEqual("the header", header) self.assertTrue("EXT1" in ext) self.assertTrue("PARSETEST" in ext) self.assertEqual(None, ext.getparam("EXT1")) self.assertEqual("DATA", ext.getparam("PARSETEST")) def test_build_string(self): possibilities = ( """\ the header EMPTY TEST STUFF""", """\ the header TEST STUFF EMPTY""", ) ret = self.ext.build_string("the header").replace("\r", "") self.assertTrue(ret in possibilities) def test_build_string_valueerror(self): class MyExtension(object): def __init__(self): pass def __str__(self): raise ValueError("test") ext = Extensions() ext.extensions = {"ONE": "OK VALUE", "TWO": MyExtension()} expected = """the header\r\nONE OK VALUE""" self.assertEqual(expected, ext.build_string("the header"))
class Server(object): """Class that implements an SMTP server given a connected socket. This object has an ``extensions`` attribute that is an |Extensions| object that contains the SMTP extensions the server supports. :param socket: Connected socket for the session. :type socket: :class:`gevent.socket.socket` :param handlers: Object with methods that will be called when corresponding SMTP commands are received. These methods can modify the |Reply| before the command response is sent. :param auth_class: Optional |Auth| sub-class to enable authentication. :param tls: Optional dictionary of TLS settings passed directly as keyword arguments to :class:`gevent.ssl.SSLSocket`. :param tls_immediately: If True, the socket will be encrypted immediately. :param tls_wrapper: Optional function that takes a socket and the ``tls`` dictionary, creates a new encrypted socket, performs the TLS handshake, and returns it. The default uses :class:`~gevent.ssl.SSLSocket`. :type tls_immediately: True or False :param command_timeout: Optional timeout waiting for a command to be sent from the client. :param data_timeout: Optional timeout waiting for data to be sent from the client. """ def __init__(self, socket, handlers, auth_class=None, tls=None, tls_immediately=False, tls_wrapper=None, command_timeout=None, data_timeout=None): self.handlers = handlers self.extensions = Extensions() self.have_mailfrom = None self.have_rcptto = None self.ehlo_as = None self.auth_result = None self.encrypted = False self.extensions.add('8BITMIME') self.extensions.add('PIPELINING') self.extensions.add('ENHANCEDSTATUSCODES') if tls and not tls_immediately: self.extensions.add('STARTTLS') if auth_class: self.extensions.add('AUTH', auth_class(self)) self.io = IO(socket, tls_wrapper) if tls: self.tls = tls.copy() self.tls.setdefault('server_side', True) else: self.tls = None self.tls_immediately = tls_immediately self.command_timeout = command_timeout self.data_timeout = data_timeout or command_timeout def _recv_command(self): timeout = Timeout(self.command_timeout) timeout.start() try: return self.io.recv_command() finally: timeout.cancel() def _get_message_data(self): max_size = self.extensions.getparam('SIZE', filter=int) reader = DataReader(self.io, max_size) err = None timeout = Timeout(self.data_timeout) timeout.start() try: data = reader.recv() except ConnectionLost: raise except SmtpError as e: data = None err = e finally: timeout.cancel() reply = Reply('250', '2.6.0 Message Accepted for Delivery') self._call_custom_handler('HAVE_DATA', reply, data, err) self.io.send_reply(reply) self.io.flush_send() self.have_mailfrom = None self.have_rcptto = None def _encrypt_session(self): if not self.io.encrypt_socket(self.tls): return False self._call_custom_handler('TLSHANDSHAKE') self.encrypted = True return True def _handle_command(self, which, arg): method = '_command_'+which if hasattr(self, method): return getattr(self, method)(arg) else: return self._command_custom(which, arg) def _call_custom_handler(self, which, *args): if hasattr(self.handlers, which): return getattr(self.handlers, which)(*args) def handle(self): """Runs through the SMTP session, receiving commands, calling handlers, and sending responses. :raises: :class:`~slimta.smtp.ConnectionLost` or unhandled exceptions. """ if self.tls and self.tls_immediately: if not self._encrypt_session(): tls_failure.send(self.io, flush=True) return command, arg = 'BANNER_', None while True: try: if command: self._handle_command(command, arg) else: unknown_command.send(self.io) except StopIteration: break except ConnectionLost: raise except TimeoutHappened: timed_out.send(self.io) self.io.flush_send() break except Exception as e: unhandled_error.send(self.io) raise finally: self.io.flush_send() try: command, arg = self._recv_command() except TimeoutHappened: timed_out.send(self.io) self.io.flush_send() break def _command_BANNER_(self, arg): reply = Reply('220', 'ESMTP server') reply.enhanced_status_code = False self._call_custom_handler('BANNER_', reply) reply.send(self.io) if reply.code != '220': self._call_custom_handler('CLOSE') raise StopIteration() def _command_EHLO(self, ehlo_as): reply = Reply('250', 'Hello {0}'.format(ehlo_as)) reply.enhanced_status_code = False self._call_custom_handler('EHLO', reply, ehlo_as) # Add extension list to message, if successful. if reply.code == '250': reply.message = self.extensions.build_string(reply.message) self.have_mailfrom = None self.have_rcptto = None self.ehlo_as = ehlo_as reply.send(self.io) def _command_HELO(self, ehlo_as): reply = Reply('250', 'Hello {0}'.format(ehlo_as)) reply.enhanced_status_code = False self._call_custom_handler('HELO', reply, ehlo_as) if reply.code == '250': self.have_mailfrom = None self.have_rcptto = None self.ehlo_as = ehlo_as self.extensions.reset() reply.send(self.io) def _command_STARTTLS(self, arg): if 'STARTTLS' not in self.extensions: unknown_command.send(self.io) return if arg: bad_arguments.send(self.io) return if not self.ehlo_as: bad_sequence.send(self.io) return reply = Reply('220', '2.7.0 Go ahead') self._call_custom_handler('STARTTLS', reply, self.extensions) reply.send(self.io, flush=True) if reply.code == '220': if not self._encrypt_session(): tls_failure.send(self.io) raise StopIteration() self.ehlo_as = None self.extensions.drop('STARTTLS') def _command_AUTH(self, arg): if 'AUTH' not in self.extensions: unknown_command.send(self.io) return if not self.ehlo_as or self.auth_result or self.have_mailfrom: bad_sequence.send(self.io) return auth = self.extensions.getparam('AUTH') reply = Reply('235', '2.7.0 Authentication successful') try: result = auth.server_attempt(self.io, arg) except ServerAuthError as e: reply.copy(e.reply) result = None reply.send(self.io) self._call_custom_handler('AUTH', reply, result) if reply.code == '235': self.auth_result = result def _command_MAIL(self, arg): match = from_pattern.match(arg) if not match: bad_arguments.send(self.io) return start = match.end(0) end = find_outside_quotes(arg, '>', start) if end == -1: bad_arguments.send(self.io) return address = arg[start:end] if not self.ehlo_as: bad_sequence.send(self.io) return if self.have_mailfrom: bad_sequence.send(self.io) return match = size_pattern.search(arg, end+1) if match: try: size = int(match.group(1)) except ValueError: bad_arguments.send(self.io) return max_size = self.extensions.getparam('SIZE', filter=int) if max_size is not None: if size > max_size: m = '5.3.4 Message size exceeds {0} limit'.format(max_size) Reply('552', m).send(self.io) return else: unknown_parameter.send(self.io) return reply = Reply('250', '2.1.0 Sender <{0}> Ok'.format(address)) self._call_custom_handler('MAIL', reply, address) reply.send(self.io) self.have_mailfrom = self.have_mailfrom or (reply.code == '250') def _command_RCPT(self, arg): match = to_pattern.match(arg) if not match: bad_arguments.send(self.io) return start = match.end(0) end = find_outside_quotes(arg, '>', start) if end == -1: bad_arguments.send(self.io) return address = arg[start:end] if not self.have_mailfrom: bad_sequence.send(self.io) return reply = Reply('250', '2.1.5 Recipient <{0}> Ok'.format(address)) self._call_custom_handler('RCPT', reply, address) reply.send(self.io) self.have_rcptto = self.have_rcptto or (reply.code == '250') def _command_DATA(self, arg): if arg: bad_arguments.send(self.io) return if not self.have_mailfrom or not self.have_rcptto: bad_sequence.send(self.io) return reply = Reply('354', 'Start mail input; end with <CRLF>.<CRLF>') self._call_custom_handler('DATA', reply) reply.send(self.io) self.io.flush_send() if reply.code == '354': self._get_message_data() def _command_RSET(self, arg): if arg: bad_arguments.send(self.io) return reply = Reply('250', 'Ok') self._call_custom_handler('RSET', reply) if reply.code == '250': self.have_mailfrom = None self.have_rcptto = None reply.send(self.io) def _command_NOOP(self, arg): reply = Reply('250', 'Ok') self._call_custom_handler('NOOP', reply) reply.send(self.io) def _command_QUIT(self, arg): if arg: bad_arguments.send(self.io) return reply = Reply('221', 'Bye') self._call_custom_handler('QUIT', reply) reply.send(self.io) if reply.code == '221': self._call_custom_handler('CLOSE') raise StopIteration() def _command_custom(self, command, arg): reply = Reply() reply.copy(unknown_command) self._call_custom_handler(command, reply, arg, self) reply.send(self.io)