1116 lines
43 KiB
Python
Executable file
1116 lines
43 KiB
Python
Executable file
#! /usr/bin/env python3
|
|
|
|
'''SMTP/ESMTP client class.
|
|
|
|
This should follow RFC 821 (SMTP), RFC 1869 (ESMTP), RFC 2554 (SMTP
|
|
Authentication) and RFC 2487 (Secure SMTP over TLS).
|
|
|
|
Notes:
|
|
|
|
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
|
|
and MAIL commands!
|
|
|
|
Example:
|
|
|
|
>>> import smtplib
|
|
>>> s=smtplib.SMTP("localhost")
|
|
>>> print(s.help())
|
|
This is Sendmail version 8.8.4
|
|
Topics:
|
|
HELO EHLO MAIL RCPT DATA
|
|
RSET NOOP QUIT HELP VRFY
|
|
EXPN VERB ETRN DSN
|
|
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.
|
|
End of HELP info
|
|
>>> s.putcmd("vrfy","someone@here")
|
|
>>> s.getreply()
|
|
(250, "Somebody OverHere <somebody@here.my.org>")
|
|
>>> s.quit()
|
|
'''
|
|
|
|
# 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.
|
|
|
|
import socket
|
|
import io
|
|
import re
|
|
import email.utils
|
|
import email.message
|
|
import email.generator
|
|
import base64
|
|
import hmac
|
|
import copy
|
|
import datetime
|
|
import sys
|
|
from email.base64mime import body_encode as encode_base64
|
|
|
|
__all__ = ["SMTPException", "SMTPServerDisconnected", "SMTPResponseException",
|
|
"SMTPSenderRefused", "SMTPRecipientsRefused", "SMTPDataError",
|
|
"SMTPConnectError", "SMTPHeloError", "SMTPAuthenticationError",
|
|
"quoteaddr", "quotedata", "SMTP"]
|
|
|
|
SMTP_PORT = 25
|
|
SMTP_SSL_PORT = 465
|
|
CRLF = "\r\n"
|
|
bCRLF = b"\r\n"
|
|
_MAXLINE = 8192 # more than 8 times larger than RFC 821, 4.5.3
|
|
|
|
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):
|
|
self.smtp_code = code
|
|
self.smtp_error = msg
|
|
self.args = (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.smtp_code = code
|
|
self.smtp_error = msg
|
|
self.sender = 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
|
|
SMTP.sendmail() returns.
|
|
"""
|
|
|
|
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):
|
|
"""Authentication error.
|
|
|
|
Most probably the server didn't accept the username/password
|
|
combination provided.
|
|
"""
|
|
|
|
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 addrstring
|
|
return "<%s>" % addrstring
|
|
return "<%s>" % addr
|
|
|
|
def _addr_only(addrstring):
|
|
displayname, addr = email.utils.parseaddr(addrstring)
|
|
if (displayname, addr) == ('', ''):
|
|
# parseaddr couldn't parse it, so use it as is.
|
|
return addrstring
|
|
return addr
|
|
|
|
# Legacy method kept for backward compatibility.
|
|
def quotedata(data):
|
|
"""Quote data for email.
|
|
|
|
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)
|
|
|
|
def _fix_eols(data):
|
|
return re.sub(r'(?:\r\n|\n|\r(?!\n))', CRLF, data)
|
|
|
|
try:
|
|
import ssl
|
|
except ImportError:
|
|
_have_ssl = False
|
|
else:
|
|
_have_ssl = True
|
|
|
|
|
|
class SMTP:
|
|
"""This class manages a connection to an SMTP or ESMTP server.
|
|
SMTP Objects:
|
|
SMTP objects have the following attributes:
|
|
helo_resp
|
|
This is the message given by the server in response to the
|
|
most recent HELO command.
|
|
|
|
ehlo_resp
|
|
This is the message given by the server in response to the
|
|
most recent EHLO command. This is usually multiline.
|
|
|
|
does_esmtp
|
|
This is a True value _after you do an EHLO command_, if the
|
|
server supports ESMTP.
|
|
|
|
esmtp_features
|
|
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
|
|
parameters (if any).
|
|
|
|
Note, all extension names are mapped to lower case in the
|
|
dictionary.
|
|
|
|
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.
|
|
"""
|
|
debuglevel = 0
|
|
file = None
|
|
helo_resp = None
|
|
ehlo_msg = "ehlo"
|
|
ehlo_resp = None
|
|
does_esmtp = 0
|
|
default_port = SMTP_PORT
|
|
|
|
def __init__(self, host='', port=0, local_hostname=None,
|
|
timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
|
|
source_address=None):
|
|
"""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
|
|
will be used.
|
|
|
|
"""
|
|
self._host = host
|
|
self.timeout = timeout
|
|
self.esmtp_features = {}
|
|
self.command_encoding = 'ascii'
|
|
self.source_address = source_address
|
|
|
|
if host:
|
|
(code, msg) = self.connect(host, port)
|
|
if code != 220:
|
|
self.close()
|
|
raise SMTPConnectError(code, msg)
|
|
if local_hostname is not None:
|
|
self.local_hostname = local_hostname
|
|
else:
|
|
# 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]).
|
|
fqdn = socket.getfqdn()
|
|
if '.' in fqdn:
|
|
self.local_hostname = fqdn
|
|
else:
|
|
# We can't find an fqdn hostname, so use a domain literal
|
|
addr = '127.0.0.1'
|
|
try:
|
|
addr = socket.gethostbyname(socket.gethostname())
|
|
except socket.gaierror:
|
|
pass
|
|
self.local_hostname = '[%s]' % addr
|
|
|
|
def __enter__(self):
|
|
return self
|
|
|
|
def __exit__(self, *args):
|
|
try:
|
|
code, message = self.docmd("QUIT")
|
|
if code != 221:
|
|
raise SMTPResponseException(code, message)
|
|
except SMTPServerDisconnected:
|
|
pass
|
|
finally:
|
|
self.close()
|
|
|
|
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):
|
|
if self.debuglevel > 1:
|
|
print(datetime.datetime.now().time(), *args, file=sys.stderr)
|
|
else:
|
|
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.
|
|
if self.debuglevel > 0:
|
|
self._print_debug('connect: to', (host, port), self.source_address)
|
|
return socket.create_connection((host, port), timeout,
|
|
self.source_address)
|
|
|
|
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.
|
|
|
|
"""
|
|
|
|
if source_address:
|
|
self.source_address = source_address
|
|
|
|
if not port and (host.find(':') == host.rfind(':')):
|
|
i = host.rfind(':')
|
|
if i >= 0:
|
|
host, port = host[:i], host[i + 1:]
|
|
try:
|
|
port = int(port)
|
|
except ValueError:
|
|
raise OSError("nonnumeric port")
|
|
if not port:
|
|
port = self.default_port
|
|
if self.debuglevel > 0:
|
|
self._print_debug('connect:', (host, port))
|
|
self.sock = self._get_socket(host, port, self.timeout)
|
|
self.file = None
|
|
(code, msg) = self.getreply()
|
|
if self.debuglevel > 0:
|
|
self._print_debug('connect:', repr(msg))
|
|
return (code, msg)
|
|
|
|
def send(self, s):
|
|
"""Send `s' to the server."""
|
|
if self.debuglevel > 0:
|
|
self._print_debug('send:', repr(s))
|
|
if hasattr(self, 'sock') and self.sock:
|
|
if isinstance(s, str):
|
|
# 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)
|
|
try:
|
|
self.sock.sendall(s)
|
|
except OSError:
|
|
self.close()
|
|
raise SMTPServerDisconnected('Server not connected')
|
|
else:
|
|
raise SMTPServerDisconnected('please run connect() first')
|
|
|
|
def putcmd(self, cmd, args=""):
|
|
"""Send a command to the server."""
|
|
if args == "":
|
|
str = '%s%s' % (cmd, CRLF)
|
|
else:
|
|
str = '%s %s%s' % (cmd, args, CRLF)
|
|
self.send(str)
|
|
|
|
def getreply(self):
|
|
"""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.
|
|
"""
|
|
resp = []
|
|
if self.file is None:
|
|
self.file = self.sock.makefile('rb')
|
|
while 1:
|
|
try:
|
|
line = self.file.readline(_MAXLINE + 1)
|
|
except OSError as e:
|
|
self.close()
|
|
raise SMTPServerDisconnected("Connection unexpectedly closed: "
|
|
+ str(e))
|
|
if not line:
|
|
self.close()
|
|
raise SMTPServerDisconnected("Connection unexpectedly closed")
|
|
if self.debuglevel > 0:
|
|
self._print_debug('reply:', repr(line))
|
|
if len(line) > _MAXLINE:
|
|
self.close()
|
|
raise SMTPResponseException(500, "Line too long.")
|
|
resp.append(line[4:].strip(b' \t\r\n'))
|
|
code = line[:3]
|
|
# Check that the error code is syntactically correct.
|
|
# Don't attempt to read a continuation line if it is broken.
|
|
try:
|
|
errcode = int(code)
|
|
except ValueError:
|
|
errcode = -1
|
|
break
|
|
# Check if multiline response.
|
|
if line[3:4] != b"-":
|
|
break
|
|
|
|
errmsg = b"\n".join(resp)
|
|
if self.debuglevel > 0:
|
|
self._print_debug('reply: retcode (%s); Msg: %a' % (errcode, errmsg))
|
|
return errcode, errmsg
|
|
|
|
def docmd(self, cmd, args=""):
|
|
"""Send a command, and return its response code."""
|
|
self.putcmd(cmd, args)
|
|
return self.getreply()
|
|
|
|
# std smtp commands
|
|
def helo(self, name=''):
|
|
"""SMTP 'helo' command.
|
|
Hostname to send for this command defaults to the FQDN of the local
|
|
host.
|
|
"""
|
|
self.putcmd("helo", name or self.local_hostname)
|
|
(code, msg) = self.getreply()
|
|
self.helo_resp = msg
|
|
return (code, msg)
|
|
|
|
def ehlo(self, name=''):
|
|
""" SMTP 'ehlo' command.
|
|
Hostname to send for this command defaults to the FQDN of the local
|
|
host.
|
|
"""
|
|
self.esmtp_features = {}
|
|
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
|
|
# that happens -ddm
|
|
if code == -1 and len(msg) == 0:
|
|
self.close()
|
|
raise SMTPServerDisconnected("Server not connected")
|
|
self.ehlo_resp = msg
|
|
if code != 250:
|
|
return (code, msg)
|
|
self.does_esmtp = 1
|
|
#parse the ehlo response -ddm
|
|
assert isinstance(self.ehlo_resp, bytes), repr(self.ehlo_resp)
|
|
resp = self.ehlo_resp.decode("latin-1").split('\n')
|
|
del resp[0]
|
|
for each in resp:
|
|
# To be able to communicate with as many SMTP servers as possible,
|
|
# we have to take the old-style auth advertisement into account,
|
|
# because:
|
|
# 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)
|
|
if auth_match:
|
|
# This doesn't remove duplicates, but that's no problem
|
|
self.esmtp_features["auth"] = self.esmtp_features.get("auth", "") \
|
|
+ " " + auth_match.groups(0)[0]
|
|
continue
|
|
|
|
# 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)
|
|
if m:
|
|
feature = m.group("feature").lower()
|
|
params = m.string[m.end("feature"):].strip()
|
|
if feature == "auth":
|
|
self.esmtp_features[feature] = self.esmtp_features.get(feature, "") \
|
|
+ " " + params
|
|
else:
|
|
self.esmtp_features[feature] = params
|
|
return (code, msg)
|
|
|
|
def has_extn(self, opt):
|
|
"""Does the server support a given SMTP service extension?"""
|
|
return opt.lower() in self.esmtp_features
|
|
|
|
def help(self, args=''):
|
|
"""SMTP 'help' command.
|
|
Returns help text from server."""
|
|
self.putcmd("help", args)
|
|
return self.getreply()[1]
|
|
|
|
def rset(self):
|
|
"""SMTP 'rset' command -- resets session."""
|
|
self.command_encoding = 'ascii'
|
|
return self.docmd("rset")
|
|
|
|
def _rset(self):
|
|
"""Internal 'rset' command which ignores any SMTPServerDisconnected error.
|
|
|
|
Used internally in the library, since the server disconnected error
|
|
should appear to the application when the *next* command is issued, if
|
|
we are doing an internal "safety" reset.
|
|
"""
|
|
try:
|
|
self.rset()
|
|
except SMTPServerDisconnected:
|
|
pass
|
|
|
|
def noop(self):
|
|
"""SMTP 'noop' command -- doesn't do anything :>"""
|
|
return self.docmd("noop")
|
|
|
|
def mail(self, sender, options=()):
|
|
"""SMTP 'mail' command -- begins mail xfer session.
|
|
|
|
This method may raise the following exceptions:
|
|
|
|
SMTPNotSupportedError The options parameter includes 'SMTPUTF8'
|
|
but the SMTPUTF8 extension is not supported by
|
|
the server.
|
|
"""
|
|
optionlist = ''
|
|
if options and self.does_esmtp:
|
|
if any(x.lower()=='smtputf8' for x in options):
|
|
if self.has_extn('smtputf8'):
|
|
self.command_encoding = 'utf-8'
|
|
else:
|
|
raise SMTPNotSupportedError(
|
|
'SMTPUTF8 not supported by server')
|
|
optionlist = ' ' + ' '.join(options)
|
|
self.putcmd("mail", "FROM:%s%s" % (quoteaddr(sender), optionlist))
|
|
return self.getreply()
|
|
|
|
def rcpt(self, recip, options=()):
|
|
"""SMTP 'rcpt' command -- indicates 1 recipient for this mail."""
|
|
optionlist = ''
|
|
if options and self.does_esmtp:
|
|
optionlist = ' ' + ' '.join(options)
|
|
self.putcmd("rcpt", "TO:%s%s" % (quoteaddr(recip), optionlist))
|
|
return self.getreply()
|
|
|
|
def data(self, msg):
|
|
"""SMTP 'DATA' command -- sends message data to server.
|
|
|
|
Automatically quotes lines beginning with a period per rfc821.
|
|
Raises SMTPDataError if there is an unexpected reply to the
|
|
DATA command; the return value from this method is the final
|
|
response code received when the all data is sent. If msg
|
|
is a string, lone '\\r' and '\\n' characters are converted to
|
|
'\\r\\n' characters. If msg is bytes, it is transmitted as is.
|
|
"""
|
|
self.putcmd("data")
|
|
(code, repl) = self.getreply()
|
|
if self.debuglevel > 0:
|
|
self._print_debug('data:', (code, repl))
|
|
if code != 354:
|
|
raise SMTPDataError(code, repl)
|
|
else:
|
|
if isinstance(msg, str):
|
|
msg = _fix_eols(msg).encode('ascii')
|
|
q = _quote_periods(msg)
|
|
if q[-2:] != bCRLF:
|
|
q = q + bCRLF
|
|
q = q + b"." + bCRLF
|
|
self.send(q)
|
|
(code, msg) = self.getreply()
|
|
if self.debuglevel > 0:
|
|
self._print_debug('data:', (code, msg))
|
|
return (code, msg)
|
|
|
|
def verify(self, address):
|
|
"""SMTP 'verify' command -- checks for address validity."""
|
|
self.putcmd("vrfy", _addr_only(address))
|
|
return self.getreply()
|
|
# a.k.a.
|
|
vrfy = verify
|
|
|
|
def expn(self, address):
|
|
"""SMTP 'expn' command -- expands a mailing list."""
|
|
self.putcmd("expn", _addr_only(address))
|
|
return self.getreply()
|
|
|
|
# some useful methods
|
|
|
|
def ehlo_or_helo_if_needed(self):
|
|
"""Call self.ehlo() and/or self.helo() if needed.
|
|
|
|
If there has been no previous EHLO or HELO command this session, this
|
|
method tries ESMTP EHLO first.
|
|
|
|
This method may raise the following exceptions:
|
|
|
|
SMTPHeloError The server didn't reply properly to
|
|
the helo greeting.
|
|
"""
|
|
if self.helo_resp is None and self.ehlo_resp is None:
|
|
if not (200 <= self.ehlo()[0] <= 299):
|
|
(code, resp) = self.helo()
|
|
if not (200 <= code <= 299):
|
|
raise SMTPHeloError(code, resp)
|
|
|
|
def auth(self, mechanism, authobject, *, initial_response_ok=True):
|
|
"""Authentication command - requires response processing.
|
|
|
|
'mechanism' specifies which authentication mechanism is to
|
|
be used - the valid values are those listed in the 'auth'
|
|
element of 'esmtp_features'.
|
|
|
|
'authobject' must be a callable object taking a single argument:
|
|
|
|
data = authobject(challenge)
|
|
|
|
It will be called to process the server's challenge response; the
|
|
challenge argument it is passed will be a bytes. It should return
|
|
an ASCII string that will be base64 encoded and sent to the server.
|
|
|
|
Keyword arguments:
|
|
- initial_response_ok: Allow sending the RFC 4954 initial-response
|
|
to the AUTH command, if the authentication methods supports it.
|
|
"""
|
|
# RFC 4954 allows auth methods to provide an initial response. Not all
|
|
# methods support it. By definition, if they return something other
|
|
# than None when challenge is None, then they do. See issue #15014.
|
|
mechanism = mechanism.upper()
|
|
initial_response = (authobject() if initial_response_ok else None)
|
|
if initial_response is not None:
|
|
response = encode_base64(initial_response.encode('ascii'), eol='')
|
|
(code, resp) = self.docmd("AUTH", mechanism + " " + response)
|
|
else:
|
|
(code, resp) = self.docmd("AUTH", mechanism)
|
|
# If server responds with a challenge, send the response.
|
|
if code == 334:
|
|
challenge = base64.decodebytes(resp)
|
|
response = encode_base64(
|
|
authobject(challenge).encode('ascii'), eol='')
|
|
(code, resp) = self.docmd(response)
|
|
if code in (235, 503):
|
|
return (code, resp)
|
|
raise SMTPAuthenticationError(code, resp)
|
|
|
|
def auth_cram_md5(self, challenge=None):
|
|
""" Authobject to use with CRAM-MD5 authentication. Requires self.user
|
|
and self.password to be set."""
|
|
# CRAM-MD5 does not support initial-response.
|
|
if challenge is None:
|
|
return None
|
|
return self.user + " " + hmac.HMAC(
|
|
self.password.encode('ascii'), challenge, 'md5').hexdigest()
|
|
|
|
def auth_plain(self, challenge=None):
|
|
""" Authobject to use with PLAIN authentication. Requires self.user and
|
|
self.password to be set."""
|
|
return "\0%s\0%s" % (self.user, self.password)
|
|
|
|
def auth_login(self, challenge=None):
|
|
""" Authobject to use with LOGIN authentication. Requires self.user and
|
|
self.password to be set."""
|
|
if challenge is None:
|
|
return self.user
|
|
else:
|
|
return self.password
|
|
|
|
def login(self, user, password, *, initial_response_ok=True):
|
|
"""Log in on an SMTP server that requires authentication.
|
|
|
|
The arguments are:
|
|
- user: The user name to authenticate with.
|
|
- password: The password for the authentication.
|
|
|
|
Keyword arguments:
|
|
- initial_response_ok: Allow sending the RFC 4954 initial-response
|
|
to the AUTH command, if the authentication methods supports it.
|
|
|
|
If there has been no previous EHLO or HELO command this session, this
|
|
method tries ESMTP EHLO first.
|
|
|
|
This method will return normally if the authentication was successful.
|
|
|
|
This method may raise the following exceptions:
|
|
|
|
SMTPHeloError The server didn't reply properly to
|
|
the helo greeting.
|
|
SMTPAuthenticationError The server didn't accept the username/
|
|
password combination.
|
|
SMTPNotSupportedError The AUTH command is not supported by the
|
|
server.
|
|
SMTPException No suitable authentication method was
|
|
found.
|
|
"""
|
|
|
|
self.ehlo_or_helo_if_needed()
|
|
if not self.has_extn("auth"):
|
|
raise SMTPNotSupportedError(
|
|
"SMTP AUTH extension not supported by server.")
|
|
|
|
# Authentication methods the server claims to support
|
|
advertised_authlist = self.esmtp_features["auth"].split()
|
|
|
|
# Authentication methods we can handle in our preferred order:
|
|
preferred_auths = ['CRAM-MD5', 'PLAIN', 'LOGIN']
|
|
|
|
# We try the supported authentications in our preferred order, if
|
|
# the server supports them.
|
|
authlist = [auth for auth in preferred_auths
|
|
if auth in advertised_authlist]
|
|
if not authlist:
|
|
raise SMTPException("No suitable authentication method found.")
|
|
|
|
# Some servers advertise authentication methods they don't really
|
|
# support, so if authentication fails, we continue until we've tried
|
|
# all methods.
|
|
self.user, self.password = user, password
|
|
for authmethod in authlist:
|
|
method_name = 'auth_' + authmethod.lower().replace('-', '_')
|
|
try:
|
|
(code, resp) = self.auth(
|
|
authmethod, getattr(self, method_name),
|
|
initial_response_ok=initial_response_ok)
|
|
# 235 == 'Authentication successful'
|
|
# 503 == 'Error: already authenticated'
|
|
if code in (235, 503):
|
|
return (code, resp)
|
|
except SMTPAuthenticationError as e:
|
|
last_exception = e
|
|
|
|
# We could not login successfully. Return result of last attempt.
|
|
raise last_exception
|
|
|
|
def starttls(self, keyfile=None, certfile=None, context=None):
|
|
"""Puts the connection to the SMTP server into TLS mode.
|
|
|
|
If there has been no previous EHLO or HELO command this session, this
|
|
method tries ESMTP EHLO first.
|
|
|
|
If the server supports TLS, this will encrypt the rest of the SMTP
|
|
session. If you provide the keyfile and certfile parameters,
|
|
the identity of the SMTP server and client can be checked. This,
|
|
however, depends on whether the socket module really checks the
|
|
certificates.
|
|
|
|
This method may raise the following exceptions:
|
|
|
|
SMTPHeloError The server didn't reply properly to
|
|
the helo greeting.
|
|
"""
|
|
self.ehlo_or_helo_if_needed()
|
|
if not self.has_extn("starttls"):
|
|
raise SMTPNotSupportedError(
|
|
"STARTTLS extension not supported by server.")
|
|
(resp, reply) = self.docmd("STARTTLS")
|
|
if resp == 220:
|
|
if not _have_ssl:
|
|
raise RuntimeError("No SSL support included in this Python")
|
|
if context is not None and keyfile is not None:
|
|
raise ValueError("context and keyfile arguments are mutually "
|
|
"exclusive")
|
|
if context is not None and certfile is not None:
|
|
raise ValueError("context and certfile arguments are mutually "
|
|
"exclusive")
|
|
if keyfile is not None or certfile is not None:
|
|
import warnings
|
|
warnings.warn("keyfile and certfile are deprecated, use a "
|
|
"custom context instead", DeprecationWarning, 2)
|
|
if context is None:
|
|
context = ssl._create_stdlib_context(certfile=certfile,
|
|
keyfile=keyfile)
|
|
self.sock = context.wrap_socket(self.sock,
|
|
server_hostname=self._host)
|
|
self.file = None
|
|
# RFC 3207:
|
|
# The client MUST discard any knowledge obtained from
|
|
# the server, such as the list of SMTP service extensions,
|
|
# which was not obtained from the TLS negotiation itself.
|
|
self.helo_resp = None
|
|
self.ehlo_resp = None
|
|
self.esmtp_features = {}
|
|
self.does_esmtp = 0
|
|
else:
|
|
# RFC 3207:
|
|
# 501 Syntax error (no parameters allowed)
|
|
# 454 TLS not available due to temporary reason
|
|
raise SMTPResponseException(resp, reply)
|
|
return (resp, reply)
|
|
|
|
def sendmail(self, from_addr, to_addrs, msg, mail_options=(),
|
|
rcpt_options=()):
|
|
"""This command performs an entire mail transaction.
|
|
|
|
The arguments are:
|
|
- from_addr : The address sending this mail.
|
|
- to_addrs : A list of addresses to send this mail to. A bare
|
|
string will be treated as a list with 1 address.
|
|
- msg : The message to send.
|
|
- mail_options : List of ESMTP options (such as 8bitmime) for the
|
|
mail command.
|
|
- rcpt_options : List of ESMTP options (such as DSN commands) for
|
|
all the rcpt commands.
|
|
|
|
msg may be a string containing characters in the ASCII range, or a byte
|
|
string. A string is encoded to bytes using the ascii codec, and lone
|
|
\\r and \\n characters are converted to \\r\\n characters.
|
|
|
|
If there has been no previous EHLO or HELO command this session, this
|
|
method tries ESMTP EHLO first. If the server does ESMTP, message size
|
|
and each of the specified options will be passed to it. If EHLO
|
|
fails, HELO will be tried and ESMTP options suppressed.
|
|
|
|
This method will return normally if the mail is accepted for at least
|
|
one recipient. It returns a dictionary, with one entry for each
|
|
recipient that was refused. Each entry contains a tuple of the SMTP
|
|
error code and the accompanying error message sent by the server.
|
|
|
|
This method may raise the following exceptions:
|
|
|
|
SMTPHeloError The server didn't reply properly to
|
|
the helo greeting.
|
|
SMTPRecipientsRefused The server rejected ALL recipients
|
|
(no mail was sent).
|
|
SMTPSenderRefused The server didn't accept the from_addr.
|
|
SMTPDataError The server replied with an unexpected
|
|
error code (other than a refusal of
|
|
a recipient).
|
|
SMTPNotSupportedError The mail_options parameter includes 'SMTPUTF8'
|
|
but the SMTPUTF8 extension is not supported by
|
|
the server.
|
|
|
|
Note: the connection will be open even after an exception is raised.
|
|
|
|
Example:
|
|
|
|
>>> import smtplib
|
|
>>> s=smtplib.SMTP("localhost")
|
|
>>> tolist=["one@one.org","two@two.org","three@three.org","four@four.org"]
|
|
>>> msg = '''\\
|
|
... From: Me@my.org
|
|
... Subject: testin'...
|
|
...
|
|
... This is a test '''
|
|
>>> s.sendmail("me@my.org",tolist,msg)
|
|
{ "three@three.org" : ( 550 ,"User unknown" ) }
|
|
>>> s.quit()
|
|
|
|
In the above example, the message was accepted for delivery to three
|
|
of the four addresses, and one was rejected, with the error code
|
|
550. If all addresses are accepted, then the method will return an
|
|
empty dictionary.
|
|
|
|
"""
|
|
self.ehlo_or_helo_if_needed()
|
|
esmtp_opts = []
|
|
if isinstance(msg, str):
|
|
msg = _fix_eols(msg).encode('ascii')
|
|
if self.does_esmtp:
|
|
if self.has_extn('size'):
|
|
esmtp_opts.append("size=%d" % len(msg))
|
|
for option in mail_options:
|
|
esmtp_opts.append(option)
|
|
(code, resp) = self.mail(from_addr, esmtp_opts)
|
|
if code != 250:
|
|
if code == 421:
|
|
self.close()
|
|
else:
|
|
self._rset()
|
|
raise SMTPSenderRefused(code, resp, from_addr)
|
|
senderrs = {}
|
|
if isinstance(to_addrs, str):
|
|
to_addrs = [to_addrs]
|
|
for each in to_addrs:
|
|
(code, resp) = self.rcpt(each, rcpt_options)
|
|
if (code != 250) and (code != 251):
|
|
senderrs[each] = (code, resp)
|
|
if code == 421:
|
|
self.close()
|
|
raise SMTPRecipientsRefused(senderrs)
|
|
if len(senderrs) == len(to_addrs):
|
|
# the server refused all our recipients
|
|
self._rset()
|
|
raise SMTPRecipientsRefused(senderrs)
|
|
(code, resp) = self.data(msg)
|
|
if code != 250:
|
|
if code == 421:
|
|
self.close()
|
|
else:
|
|
self._rset()
|
|
raise SMTPDataError(code, resp)
|
|
#if we got here then somebody got our mail
|
|
return senderrs
|
|
|
|
def send_message(self, msg, from_addr=None, to_addrs=None,
|
|
mail_options=(), rcpt_options=()):
|
|
"""Converts message to a bytestring and passes it to sendmail.
|
|
|
|
The arguments are as for sendmail, except that msg is an
|
|
email.message.Message object. If from_addr is None or to_addrs is
|
|
None, these arguments are taken from the headers of the Message as
|
|
described in RFC 2822 (a ValueError is raised if there is more than
|
|
one set of 'Resent-' headers). Regardless of the values of from_addr and
|
|
to_addr, any Bcc field (or Resent-Bcc field, when the Message is a
|
|
resent) of the Message object won't be transmitted. The Message
|
|
object is then serialized using email.generator.BytesGenerator and
|
|
sendmail is called to transmit the message. If the sender or any of
|
|
the recipient addresses contain non-ASCII and the server advertises the
|
|
SMTPUTF8 capability, the policy is cloned with utf8 set to True for the
|
|
serialization, and SMTPUTF8 and BODY=8BITMIME are asserted on the send.
|
|
If the server does not support SMTPUTF8, an SMTPNotSupported error is
|
|
raised. Otherwise the generator is called without modifying the
|
|
policy.
|
|
|
|
"""
|
|
# 'Resent-Date' is a mandatory field if the Message is resent (RFC 2822
|
|
# Section 3.6.6). In such a case, we use the 'Resent-*' fields. However,
|
|
# if there is more than one 'Resent-' block there's no way to
|
|
# unambiguously determine which one is the most recent in all cases,
|
|
# so rather than guess we raise a ValueError in that case.
|
|
#
|
|
# TODO implement heuristics to guess the correct Resent-* block with an
|
|
# option allowing the user to enable the heuristics. (It should be
|
|
# possible to guess correctly almost all of the time.)
|
|
|
|
self.ehlo_or_helo_if_needed()
|
|
resent = msg.get_all('Resent-Date')
|
|
if resent is None:
|
|
header_prefix = ''
|
|
elif len(resent) == 1:
|
|
header_prefix = 'Resent-'
|
|
else:
|
|
raise ValueError("message has more than one 'Resent-' header block")
|
|
if from_addr is None:
|
|
# Prefer the sender field per RFC 2822:3.6.2.
|
|
from_addr = (msg[header_prefix + 'Sender']
|
|
if (header_prefix + 'Sender') in msg
|
|
else msg[header_prefix + 'From'])
|
|
from_addr = email.utils.getaddresses([from_addr])[0][1]
|
|
if to_addrs is None:
|
|
addr_fields = [f for f in (msg[header_prefix + 'To'],
|
|
msg[header_prefix + 'Bcc'],
|
|
msg[header_prefix + 'Cc'])
|
|
if f is not None]
|
|
to_addrs = [a[1] for a in email.utils.getaddresses(addr_fields)]
|
|
# Make a local copy so we can delete the bcc headers.
|
|
msg_copy = copy.copy(msg)
|
|
del msg_copy['Bcc']
|
|
del msg_copy['Resent-Bcc']
|
|
international = False
|
|
try:
|
|
''.join([from_addr, *to_addrs]).encode('ascii')
|
|
except UnicodeEncodeError:
|
|
if not self.has_extn('smtputf8'):
|
|
raise SMTPNotSupportedError(
|
|
"One or more source or delivery addresses require"
|
|
" internationalized email support, but the server"
|
|
" does not advertise the required SMTPUTF8 capability")
|
|
international = True
|
|
with io.BytesIO() as bytesmsg:
|
|
if international:
|
|
g = email.generator.BytesGenerator(
|
|
bytesmsg, policy=msg.policy.clone(utf8=True))
|
|
mail_options = (*mail_options, 'SMTPUTF8', 'BODY=8BITMIME')
|
|
else:
|
|
g = email.generator.BytesGenerator(bytesmsg)
|
|
g.flatten(msg_copy, linesep='\r\n')
|
|
flatmsg = bytesmsg.getvalue()
|
|
return self.sendmail(from_addr, to_addrs, flatmsg, mail_options,
|
|
rcpt_options)
|
|
|
|
def close(self):
|
|
"""Close the connection to the SMTP server."""
|
|
try:
|
|
file = self.file
|
|
self.file = None
|
|
if file:
|
|
file.close()
|
|
finally:
|
|
sock = self.sock
|
|
self.sock = None
|
|
if sock:
|
|
sock.close()
|
|
|
|
def quit(self):
|
|
"""Terminate the SMTP session."""
|
|
res = self.docmd("quit")
|
|
# A new EHLO is required after reconnecting with connect()
|
|
self.ehlo_resp = self.helo_resp = None
|
|
self.esmtp_features = {}
|
|
self.does_esmtp = False
|
|
self.close()
|
|
return res
|
|
|
|
if _have_ssl:
|
|
|
|
class SMTP_SSL(SMTP):
|
|
""" This is a subclass derived from SMTP that connects over an SSL
|
|
encrypted socket (to use this class you need a socket module that was
|
|
compiled with SSL support). If host is not specified, '' (the local
|
|
host) is used. If port is omitted, the standard SMTP-over-SSL port
|
|
(465) is used. local_hostname and source_address have the same meaning
|
|
as they do in the SMTP class. keyfile and certfile are also optional -
|
|
they can contain a PEM formatted private key and certificate chain file
|
|
for the SSL connection. context also optional, can contain a
|
|
SSLContext, and is an alternative to keyfile and certfile; If it is
|
|
specified both keyfile and certfile must be None.
|
|
|
|
"""
|
|
|
|
default_port = SMTP_SSL_PORT
|
|
|
|
def __init__(self, host='', port=0, local_hostname=None,
|
|
keyfile=None, certfile=None,
|
|
timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
|
|
source_address=None, context=None):
|
|
if context is not None and keyfile is not None:
|
|
raise ValueError("context and keyfile arguments are mutually "
|
|
"exclusive")
|
|
if context is not None and certfile is not None:
|
|
raise ValueError("context and certfile arguments are mutually "
|
|
"exclusive")
|
|
if keyfile is not None or certfile is not None:
|
|
import warnings
|
|
warnings.warn("keyfile and certfile are deprecated, use a "
|
|
"custom context instead", DeprecationWarning, 2)
|
|
self.keyfile = keyfile
|
|
self.certfile = certfile
|
|
if context is None:
|
|
context = ssl._create_stdlib_context(certfile=certfile,
|
|
keyfile=keyfile)
|
|
self.context = context
|
|
SMTP.__init__(self, host, port, local_hostname, timeout,
|
|
source_address)
|
|
|
|
def _get_socket(self, host, port, timeout):
|
|
if self.debuglevel > 0:
|
|
self._print_debug('connect:', (host, port))
|
|
new_socket = socket.create_connection((host, port), timeout,
|
|
self.source_address)
|
|
new_socket = self.context.wrap_socket(new_socket,
|
|
server_hostname=self._host)
|
|
return new_socket
|
|
|
|
__all__.append("SMTP_SSL")
|
|
|
|
#
|
|
# LMTP extension
|
|
#
|
|
LMTP_PORT = 2003
|
|
|
|
class LMTP(SMTP):
|
|
"""LMTP - Local Mail Transfer Protocol
|
|
|
|
The LMTP protocol, which is very similar to ESMTP, is heavily based
|
|
on the standard SMTP client. It's common to use Unix sockets for
|
|
LMTP, so our connect() method must support that as well as a regular
|
|
host:port server. local_hostname and source_address have the same
|
|
meaning as they do in the SMTP class. To specify a Unix socket,
|
|
you must use an absolute path as the host, starting with a '/'.
|
|
|
|
Authentication is supported, using the regular SMTP mechanism. When
|
|
using a Unix socket, LMTP generally don't support or require any
|
|
authentication, but your mileage might vary."""
|
|
|
|
ehlo_msg = "lhlo"
|
|
|
|
def __init__(self, host='', port=LMTP_PORT, local_hostname=None,
|
|
source_address=None):
|
|
"""Initialize a new instance."""
|
|
SMTP.__init__(self, host, port, local_hostname=local_hostname,
|
|
source_address=source_address)
|
|
|
|
def connect(self, host='localhost', port=0, source_address=None):
|
|
"""Connect to the LMTP daemon, on either a Unix or a TCP socket."""
|
|
if host[0] != '/':
|
|
return SMTP.connect(self, host, port, source_address=source_address)
|
|
|
|
# Handle Unix-domain sockets.
|
|
try:
|
|
self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
|
|
self.file = None
|
|
self.sock.connect(host)
|
|
except OSError:
|
|
if self.debuglevel > 0:
|
|
self._print_debug('connect fail:', host)
|
|
if self.sock:
|
|
self.sock.close()
|
|
self.sock = None
|
|
raise
|
|
(code, msg) = self.getreply()
|
|
if self.debuglevel > 0:
|
|
self._print_debug('connect:', msg)
|
|
return (code, msg)
|
|
|
|
|
|
# Test the sendmail method, which tests most of the others.
|
|
# Note: This always sends to localhost.
|
|
if __name__ == '__main__':
|
|
def prompt(prompt):
|
|
sys.stdout.write(prompt + ": ")
|
|
sys.stdout.flush()
|
|
return sys.stdin.readline().strip()
|
|
|
|
fromaddr = prompt("From")
|
|
toaddrs = prompt("To").split(',')
|
|
print("Enter message, end with ^D:")
|
|
msg = ''
|
|
while 1:
|
|
line = sys.stdin.readline()
|
|
if not line:
|
|
break
|
|
msg = msg + line
|
|
print("Message length is %d" % len(msg))
|
|
|
|
server = SMTP('localhost')
|
|
server.set_debuglevel(1)
|
|
server.sendmail(fromaddr, toaddrs, msg)
|
|
server.quit()
|