'''SMTP/ESMTP client class.
This should follow RFC 821 (SMTP), RFC 1869 (ESMTP), RFC 2554 (SMTP
Authentication) and RFC 2487 (Secure SMTP over TLS).
Please remember, when doing ESMTP, that the names of the SMTP service
extensions are NOT the same thing as the option keywords for the RCPT
>>> s=smtplib.SMTP("localhost")
This is Sendmail version 8.8.4
For more info use "HELP <topic>".
To report bugs in the implementation send email to
sendmail-bugs@sendmail.org.
For local information send email to Postmaster at your site.
>>> s.putcmd("vrfy","someone@here")
(250, "Somebody OverHere <somebody@here.my.org>")
# Author: The Dragon De Monsyne <dragondm@integral.org>
# ESMTP support, test code and doc fixes added by
# Eric S. Raymond <esr@thyrsus.com>
# Better RFC 821 compliance (MAIL and RCPT, and CRLF in data)
# by Carey Evans <c.evans@clear.net.nz>, for picky mail servers.
# RFC 2554 (authentication) support by Gerhard Haering <gerhard@bigfoot.de>.
# This was modified from the Python 1.5 library HTTP lib.
from email.base64mime import body_encode as encode_base64
__all__ = ["SMTPException", "SMTPNotSupportedError", "SMTPServerDisconnected", "SMTPResponseException",
"SMTPSenderRefused", "SMTPRecipientsRefused", "SMTPDataError",
"SMTPConnectError", "SMTPHeloError", "SMTPAuthenticationError",
"quoteaddr", "quotedata", "SMTP"]
_MAXLINE = 8192 # more than 8 times larger than RFC 821, 4.5.3
_MAXCHALLENGE = 5 # Maximum number of AUTH challenges sent
OLDSTYLE_AUTH = re.compile(r"auth=(.*)", re.I)
# Exception classes used by this module.
class SMTPException(OSError):
"""Base class for all exceptions raised by this module."""
class SMTPNotSupportedError(SMTPException):
"""The command or option is not supported by the SMTP server.
This exception is raised when an attempt is made to run a command or a
command with an option which is not supported by the server.
class SMTPServerDisconnected(SMTPException):
"""Not connected to any SMTP server.
This exception is raised when the server unexpectedly disconnects,
or when an attempt is made to use the SMTP instance before
connecting it to a server.
class SMTPResponseException(SMTPException):
"""Base class for all exceptions that include an SMTP error code.
These exceptions are generated in some instances when the SMTP
server returns an error code. The error code is stored in the
`smtp_code' attribute of the error, and the `smtp_error' attribute
is set to the error message.
def __init__(self, code, msg):
class SMTPSenderRefused(SMTPResponseException):
"""Sender address refused.
In addition to the attributes set by on all SMTPResponseException
exceptions, this sets `sender' to the string that the SMTP refused.
def __init__(self, code, msg, sender):
self.args = (code, msg, sender)
class SMTPRecipientsRefused(SMTPException):
"""All recipient addresses refused.
The errors for each recipient are accessible through the attribute
'recipients', which is a dictionary of exactly the same sort as
def __init__(self, recipients):
self.recipients = recipients
self.args = (recipients,)
class SMTPDataError(SMTPResponseException):
"""The SMTP server didn't accept the data."""
class SMTPConnectError(SMTPResponseException):
"""Error during connection establishment."""
class SMTPHeloError(SMTPResponseException):
"""The server refused our HELO reply."""
class SMTPAuthenticationError(SMTPResponseException):
Most probably the server didn't accept the username/password
def quoteaddr(addrstring):
"""Quote a subset of the email addresses defined by RFC 821.
Should be able to handle anything email.utils.parseaddr can handle.
displayname, addr = email.utils.parseaddr(addrstring)
if (displayname, addr) == ('', ''):
# parseaddr couldn't parse it, use it as is and hope for the best.
if addrstring.strip().startswith('<'):
return "<%s>" % addrstring
def _addr_only(addrstring):
displayname, addr = email.utils.parseaddr(addrstring)
if (displayname, addr) == ('', ''):
# parseaddr couldn't parse it, so use it as is.
# Legacy method kept for backward compatibility.
Double leading '.', and change Unix newline '\\n', or Mac '\\r' into
Internet CRLF end-of-line.
return re.sub(r'(?m)^\.', '..',
re.sub(r'(?:\r\n|\n|\r(?!\n))', CRLF, data))
def _quote_periods(bindata):
return re.sub(br'(?m)^\.', b'..', bindata)
return re.sub(r'(?:\r\n|\n|\r(?!\n))', CRLF, data)
"""This class manages a connection to an SMTP or ESMTP server.
SMTP objects have the following attributes:
This is the message given by the server in response to the
most recent HELO command.
This is the message given by the server in response to the
most recent EHLO command. This is usually multiline.
This is a True value _after you do an EHLO command_, if the
This is a dictionary, which, if the server supports ESMTP,
will _after you do an EHLO command_, contain the names of the
SMTP service extensions this server supports, and their
Note, all extension names are mapped to lower case in the
See each method's docstrings for details. In general, there is a
method of the same name to perform each SMTP command. There is also a
method called 'sendmail' that will do an entire mail transaction.
def __init__(self, host='', port=0, local_hostname=None,
timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
"""Initialize a new instance.
If specified, `host` is the name of the remote host to which to
connect. If specified, `port` specifies the port to which to connect.
By default, smtplib.SMTP_PORT is used. If a host is specified the
connect method is called, and if it returns anything other than a
success code an SMTPConnectError is raised. If specified,
`local_hostname` is used as the FQDN of the local host in the HELO/EHLO
command. Otherwise, the local hostname is found using
socket.getfqdn(). The `source_address` parameter takes a 2-tuple (host,
port) for the socket to bind to as its source address before
connecting. If the host is '' and port is 0, the OS default behavior
self.command_encoding = 'ascii'
self.source_address = source_address
self._auth_challenge_count = 0
(code, msg) = self.connect(host, port)
raise SMTPConnectError(code, msg)
if local_hostname is not None:
self.local_hostname = local_hostname
# RFC 2821 says we should use the fqdn in the EHLO/HELO verb, and
# if that can't be calculated, that we should use a domain literal
# instead (essentially an encoded IP address like [A.B.C.D]).
self.local_hostname = fqdn
# We can't find an fqdn hostname, so use a domain literal
addr = socket.gethostbyname(socket.gethostname())
self.local_hostname = '[%s]' % addr
def __exit__(self, *args):
code, message = self.docmd("QUIT")
raise SMTPResponseException(code, message)
except SMTPServerDisconnected:
def set_debuglevel(self, debuglevel):
"""Set the debug output level.
A non-false value results in debug messages for connection and for all
messages sent to and received from the server.
self.debuglevel = debuglevel
def _print_debug(self, *args):
print(datetime.datetime.now().time(), *args, file=sys.stderr)
print(*args, file=sys.stderr)
def _get_socket(self, host, port, timeout):
# This makes it simpler for SMTP_SSL to use the SMTP connect code
# and just alter the socket connection bit.
self._print_debug('connect: to', (host, port), self.source_address)
return socket.create_connection((host, port), timeout,
def connect(self, host='localhost', port=0, source_address=None):
"""Connect to a host on a given port.
If the hostname ends with a colon (`:') followed by a number, and
there is no port specified, that suffix will be stripped off and the
number interpreted as the port number to use.
Note: This method is automatically invoked by __init__, if a host is
specified during instantiation.
self.source_address = source_address
if not port and (host.find(':') == host.rfind(':')):
host, port = host[:i], host[i + 1:]
raise OSError("nonnumeric port")
sys.audit("smtplib.connect", self, host, port)
self.sock = self._get_socket(host, port, self.timeout)
(code, msg) = self.getreply()
self._print_debug('connect:', repr(msg))
"""Send `s' to the server."""
self._print_debug('send:', repr(s))
# send is used by the 'data' command, where command_encoding
# should not be used, but 'data' needs to convert the string to
# binary itself anyway, so that's not a problem.
s = s.encode(self.command_encoding)
sys.audit("smtplib.send", self, s)
raise SMTPServerDisconnected('Server not connected')
raise SMTPServerDisconnected('please run connect() first')
def putcmd(self, cmd, args=""):
"""Send a command to the server."""
if '\r' in s or '\n' in s:
s = s.replace('\n', '\\n').replace('\r', '\\r')
f'command and arguments contain prohibited newline characters: {s}'
"""Get a reply from the server.
Returns a tuple consisting of:
- server response code (e.g. '250', or such, if all goes well)
Note: returns -1 if it can't read response code.
- server response string corresponding to response code (multiline
responses are converted to a single, multiline string).
Raises SMTPServerDisconnected if end-of-file is reached.
self.file = self.sock.makefile('rb')
line = self.file.readline(_MAXLINE + 1)
raise SMTPServerDisconnected("Connection unexpectedly closed: "
raise SMTPServerDisconnected("Connection unexpectedly closed")
self._print_debug('reply:', repr(line))
raise SMTPResponseException(500, "Line too long.")
resp.append(line[4:].strip(b' \t\r\n'))
# Check that the error code is syntactically correct.
# Don't attempt to read a continuation line if it is broken.
# Check if multiline response.
errmsg = b"\n".join(resp)
self._print_debug('reply: retcode (%s); Msg: %a' % (errcode, errmsg))
def docmd(self, cmd, args=""):
"""Send a command, and return its response code."""
Hostname to send for this command defaults to the FQDN of the local
self.putcmd("helo", name or self.local_hostname)
(code, msg) = self.getreply()
Hostname to send for this command defaults to the FQDN of the local
self.putcmd(self.ehlo_msg, name or self.local_hostname)
(code, msg) = self.getreply()
# According to RFC1869 some (badly written)
# MTA's will disconnect on an ehlo. Toss an exception if
if code == -1 and len(msg) == 0:
raise SMTPServerDisconnected("Server not connected")
#parse the ehlo response -ddm
assert isinstance(self.ehlo_resp, bytes), repr(self.ehlo_resp)
resp = self.ehlo_resp.decode("latin-1").split('\n')
# To be able to communicate with as many SMTP servers as possible,
# we have to take the old-style auth advertisement into account,
# 1) Else our SMTP feature parser gets confused.
# 2) There are some servers that only advertise the auth methods we
# support using the old style.
auth_match = OLDSTYLE_AUTH.match(each)
# This doesn't remove duplicates, but that's no problem
self.esmtp_features["auth"] = self.esmtp_features.get("auth", "") \
+ " " + auth_match.groups(0)[0]
# RFC 1869 requires a space between ehlo keyword and parameters.
# It's actually stricter, in that only spaces are allowed between
# parameters, but were not going to check for that here. Note
# that the space isn't present if there are no parameters.
m = re.match(r'(?P<feature>[A-Za-z0-9][A-Za-z0-9\-]*) ?', each)
feature = m.group("feature").lower()
params = m.string[m.end("feature"):].strip()
self.esmtp_features[feature] = self.esmtp_features.get(feature, "") \
self.esmtp_features[feature] = params
"""Does the server support a given SMTP service extension?"""
return opt.lower() in self.esmtp_features
Returns help text from server."""
It is recommended that you Edit text format, this type of Fix handles quite a lot in one request
