mail.py
336 lines
| 11.8 KiB
| text/x-python
|
PythonLexer
/ mercurial / mail.py
|
r2889 | # mail.py - mail sending bits for mercurial | ||
# | ||||
# Copyright 2006 Matt Mackall <mpm@selenic.com> | ||||
# | ||||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r2889 | |||
|
r30325 | from __future__ import absolute_import | ||
|
r25957 | |||
|
r19790 | import email | ||
|
r30089 | import email.charset | ||
|
r30072 | import email.header | ||
|
r34311 | import email.message | ||
|
r25957 | import os | ||
import smtplib | ||||
import socket | ||||
import time | ||||
from .i18n import _ | ||||
from . import ( | ||||
encoding, | ||||
|
r26587 | error, | ||
|
r25957 | sslutil, | ||
util, | ||||
) | ||||
|
r2889 | |||
|
r18885 | class STARTTLS(smtplib.SMTP): | ||
'''Derived class to verify the peer certificate for STARTTLS. | ||||
This class allows to pass any keyword arguments to SSL socket creation. | ||||
''' | ||||
|
r29251 | def __init__(self, ui, host=None, **kwargs): | ||
|
r18885 | smtplib.SMTP.__init__(self, **kwargs) | ||
|
r29248 | self._ui = ui | ||
|
r28935 | self._host = host | ||
|
r18885 | |||
def starttls(self, keyfile=None, certfile=None): | ||||
if not self.has_extn("starttls"): | ||||
msg = "STARTTLS extension not supported by server" | ||||
raise smtplib.SMTPException(msg) | ||||
(resp, reply) = self.docmd("STARTTLS") | ||||
if resp == 220: | ||||
|
r25429 | self.sock = sslutil.wrapsocket(self.sock, keyfile, certfile, | ||
|
r29248 | ui=self._ui, | ||
|
r29251 | serverhostname=self._host) | ||
|
r18885 | self.file = smtplib.SSLFakeFile(self.sock) | ||
self.helo_resp = None | ||||
self.ehlo_resp = None | ||||
self.esmtp_features = {} | ||||
self.does_esmtp = 0 | ||||
return (resp, reply) | ||||
|
r26673 | class SMTPS(smtplib.SMTP): | ||
'''Derived class to verify the peer certificate for SMTPS. | ||||
|
r18886 | |||
|
r26673 | This class allows to pass any keyword arguments to SSL socket creation. | ||
''' | ||||
|
r29251 | def __init__(self, ui, keyfile=None, certfile=None, host=None, | ||
|
r28935 | **kwargs): | ||
|
r26673 | self.keyfile = keyfile | ||
self.certfile = certfile | ||||
smtplib.SMTP.__init__(self, **kwargs) | ||||
|
r28935 | self._host = host | ||
|
r26673 | self.default_port = smtplib.SMTP_SSL_PORT | ||
|
r29248 | self._ui = ui | ||
|
r26673 | |||
def _get_socket(self, host, port, timeout): | ||||
if self.debuglevel > 0: | ||||
|
r30325 | self._ui.debug('connect: %r\n' % (host, port)) | ||
|
r26673 | new_socket = socket.create_connection((host, port), timeout) | ||
new_socket = sslutil.wrapsocket(new_socket, | ||||
self.keyfile, self.certfile, | ||||
|
r29248 | ui=self._ui, | ||
|
r29251 | serverhostname=self._host) | ||
|
r26673 | self.file = smtplib.SSLFakeFile(new_socket) | ||
return new_socket | ||||
|
r18886 | |||
|
r2889 | def _smtp(ui): | ||
|
r5973 | '''build an smtp connection and return a function to send mail''' | ||
|
r2889 | local_hostname = ui.config('smtp', 'local_hostname') | ||
|
r33499 | tls = ui.config('smtp', 'tls') | ||
|
r13201 | # backward compatible: when tls = true, we use starttls. | ||
starttls = tls == 'starttls' or util.parsebool(tls) | ||||
smtps = tls == 'smtps' | ||||
|
r14965 | if (starttls or smtps) and not util.safehasattr(socket, 'ssl'): | ||
|
r26587 | raise error.Abort(_("can't use TLS: Python SSL support not installed")) | ||
|
r2889 | mailhost = ui.config('smtp', 'host') | ||
if not mailhost: | ||||
|
r26587 | raise error.Abort(_('smtp.host not configured - cannot send mail')) | ||
|
r18888 | if smtps: | ||
ui.note(_('(using smtps)\n')) | ||||
|
r29251 | s = SMTPS(ui, local_hostname=local_hostname, host=mailhost) | ||
|
r18888 | elif starttls: | ||
|
r29251 | s = STARTTLS(ui, local_hostname=local_hostname, host=mailhost) | ||
|
r18888 | else: | ||
s = smtplib.SMTP(local_hostname=local_hostname) | ||||
|
r19050 | if smtps: | ||
defaultport = 465 | ||||
else: | ||||
defaultport = 25 | ||||
mailport = util.getport(ui.config('smtp', 'port', defaultport)) | ||||
|
r26778 | ui.note(_('sending mail: smtp host %s, port %d\n') % | ||
|
r2964 | (mailhost, mailport)) | ||
|
r2889 | s.connect(host=mailhost, port=mailport) | ||
|
r13201 | if starttls: | ||
ui.note(_('(using starttls)\n')) | ||||
|
r2889 | s.ehlo() | ||
s.starttls() | ||||
s.ehlo() | ||||
|
r29285 | if starttls or smtps: | ||
|
r18888 | ui.note(_('(verifying remote certificate)\n')) | ||
|
r29285 | sslutil.validatesocket(s.sock) | ||
|
r2889 | username = ui.config('smtp', 'username') | ||
password = ui.config('smtp', 'password') | ||||
|
r5749 | if username and not password: | ||
password = ui.getpass() | ||||
|
r2889 | if username and password: | ||
ui.note(_('(authenticating to mail server as %s)\n') % | ||||
(username)) | ||||
|
r9246 | try: | ||
s.login(username, password) | ||||
|
r25660 | except smtplib.SMTPException as inst: | ||
|
r26587 | raise error.Abort(inst) | ||
|
r2889 | |||
|
r5973 | def send(sender, recipients, msg): | ||
try: | ||||
return s.sendmail(sender, recipients, msg) | ||||
|
r25660 | except smtplib.SMTPRecipientsRefused as inst: | ||
|
r5973 | recipients = [r[1] for r in inst.recipients.values()] | ||
|
r26587 | raise error.Abort('\n' + '\n'.join(recipients)) | ||
|
r25660 | except smtplib.SMTPException as inst: | ||
|
r26587 | raise error.Abort(inst) | ||
|
r5947 | |||
|
r5973 | return send | ||
|
r5947 | |||
|
r5973 | def _sendmail(ui, sender, recipients, msg): | ||
'''send mail using sendmail.''' | ||||
|
r33499 | program = ui.config('email', 'method') | ||
|
r5975 | cmdline = '%s -f %s %s' % (program, util.email(sender), | ||
' '.join(map(util.email, recipients))) | ||||
|
r5973 | ui.note(_('sending mail: %s\n') % cmdline) | ||
|
r6548 | fp = util.popen(cmdline, 'w') | ||
|
r5973 | fp.write(msg) | ||
ret = fp.close() | ||||
if ret: | ||||
|
r26587 | raise error.Abort('%s %s' % ( | ||
|
r5973 | os.path.basename(program.split(None, 1)[0]), | ||
|
r14234 | util.explainexit(ret)[0])) | ||
|
r2889 | |||
|
r15560 | def _mbox(mbox, sender, recipients, msg): | ||
'''write mails to mbox''' | ||||
fp = open(mbox, 'ab+') | ||||
# Should be time.asctime(), but Windows prints 2-characters day | ||||
# of month instead of one. Make them print the same thing. | ||||
|
r35152 | date = time.strftime(r'%a %b %d %H:%M:%S %Y', time.localtime()) | ||
|
r15560 | fp.write('From %s %s\n' % (sender, date)) | ||
fp.write(msg) | ||||
fp.write('\n\n') | ||||
fp.close() | ||||
def connect(ui, mbox=None): | ||||
|
r5973 | '''make a mail connection. return a function to send mail. | ||
|
r2889 | call as sendmail(sender, list-of-recipients, msg).''' | ||
|
r15560 | if mbox: | ||
open(mbox, 'wb').close() | ||||
return lambda s, r, m: _mbox(mbox, s, r, m) | ||||
|
r33499 | if ui.config('email', 'method') == 'smtp': | ||
|
r5947 | return _smtp(ui) | ||
|
r5973 | return lambda s, r, m: _sendmail(ui, s, r, m) | ||
|
r2889 | |||
|
r15561 | def sendmail(ui, sender, recipients, msg, mbox=None): | ||
send = connect(ui, mbox=mbox) | ||||
|
r5973 | return send(sender, recipients, msg) | ||
|
r4489 | |||
def validateconfig(ui): | ||||
'''determine if we have enough config data to try sending email.''' | ||||
|
r33499 | method = ui.config('email', 'method') | ||
|
r4489 | if method == 'smtp': | ||
if not ui.config('smtp', 'host'): | ||||
|
r26587 | raise error.Abort(_('smtp specified as email transport, ' | ||
|
r4489 | 'but no smtp host configured')) | ||
else: | ||||
|
r14271 | if not util.findexe(method): | ||
|
r26587 | raise error.Abort(_('%r specified as email transport, ' | ||
|
r4489 | 'but not in PATH') % method) | ||
|
r7114 | |||
|
r30089 | def codec2iana(cs): | ||
'''''' | ||||
cs = email.charset.Charset(cs).input_charset.lower() | ||||
# "latin1" normalizes to "iso8859-1", standard calls for "iso-8859-1" | ||||
if cs.startswith("iso") and not cs.startswith("iso-"): | ||||
return "iso-" + cs[3:] | ||||
return cs | ||||
|
r7191 | def mimetextpatch(s, subtype='plain', display=False): | ||
|
r15562 | '''Return MIME message suitable for a patch. | ||
|
r30089 | Charset will be detected by first trying to decode as us-ascii, then utf-8, | ||
and finally the global encodings. If all those fail, fall back to | ||||
ISO-8859-1, an encoding with that allows all byte sequences. | ||||
|
r15562 | Transfer encodings will be used if necessary.''' | ||
|
r8332 | |||
|
r30089 | cs = ['us-ascii', 'utf-8', encoding.encoding, encoding.fallbackencoding] | ||
if display: | ||||
return mimetextqp(s, subtype, 'us-ascii') | ||||
for charset in cs: | ||||
|
r8332 | try: | ||
|
r30089 | s.decode(charset) | ||
return mimetextqp(s, subtype, codec2iana(charset)) | ||||
|
r8332 | except UnicodeDecodeError: | ||
|
r30089 | pass | ||
|
r8332 | |||
|
r30089 | return mimetextqp(s, subtype, "iso-8859-1") | ||
|
r15562 | |||
def mimetextqp(body, subtype, charset): | ||||
'''Return MIME message. | ||||
|
r17424 | Quoted-printable transfer encoding will be used if necessary. | ||
|
r15562 | ''' | ||
|
r34311 | cs = email.charset.Charset(charset) | ||
msg = email.message.Message() | ||||
msg.set_type('text/' + subtype) | ||||
|
r15562 | for line in body.splitlines(): | ||
if len(line) > 950: | ||||
|
r34311 | cs.body_encoding = email.charset.QP | ||
|
r15562 | break | ||
|
r34311 | msg.set_payload(body, cs) | ||
|
r8332 | return msg | ||
|
r7191 | |||
|
r7114 | def _charsets(ui): | ||
'''Obtains charsets to send mail parts not containing patches.''' | ||||
charsets = [cs.lower() for cs in ui.configlist('email', 'charsets')] | ||||
|
r7948 | fallbacks = [encoding.fallbackencoding.lower(), | ||
encoding.encoding.lower(), 'utf-8'] | ||||
|
r8343 | for cs in fallbacks: # find unique charsets while keeping order | ||
|
r7114 | if cs not in charsets: | ||
charsets.append(cs) | ||||
return [cs for cs in charsets if not cs.endswith('ascii')] | ||||
def _encode(ui, s, charsets): | ||||
'''Returns (converted) string, charset tuple. | ||||
Finds out best charset by cycling through sendcharsets in descending | ||||
|
r7948 | order. Tries both encoding and fallbackencoding for input. Only as | ||
|
r7114 | last resort send as is in fake ascii. | ||
Caveat: Do not use for mail parts containing patches!''' | ||||
try: | ||||
s.decode('ascii') | ||||
except UnicodeDecodeError: | ||||
sendcharsets = charsets or _charsets(ui) | ||||
|
r7948 | for ics in (encoding.encoding, encoding.fallbackencoding): | ||
|
r7114 | try: | ||
u = s.decode(ics) | ||||
except UnicodeDecodeError: | ||||
continue | ||||
for ocs in sendcharsets: | ||||
try: | ||||
return u.encode(ocs), ocs | ||||
except UnicodeEncodeError: | ||||
pass | ||||
except LookupError: | ||||
|
r7195 | ui.warn(_('ignoring invalid sendcharset: %s\n') % ocs) | ||
|
r7114 | # if ascii, or all conversion attempts fail, send (broken) ascii | ||
return s, 'us-ascii' | ||||
def headencode(ui, s, charsets=None, display=False): | ||||
'''Returns RFC-2047 compliant header from given string.''' | ||||
if not display: | ||||
# split into words? | ||||
s, cs = _encode(ui, s, charsets) | ||||
|
r30072 | return str(email.header.Header(s, cs)) | ||
|
r7114 | return s | ||
|
r9948 | def _addressencode(ui, name, addr, charsets=None): | ||
|
r7114 | name = headencode(ui, name, charsets) | ||
try: | ||||
acc, dom = addr.split('@') | ||||
acc = acc.encode('ascii') | ||||
|
r9715 | dom = dom.decode(encoding.encoding).encode('idna') | ||
|
r7114 | addr = '%s@%s' % (acc, dom) | ||
except UnicodeDecodeError: | ||||
|
r26587 | raise error.Abort(_('invalid email address: %s') % addr) | ||
|
r7114 | except ValueError: | ||
try: | ||||
# too strict? | ||||
addr = addr.encode('ascii') | ||||
except UnicodeDecodeError: | ||||
|
r26587 | raise error.Abort(_('invalid local address: %s') % addr) | ||
|
r7114 | return email.Utils.formataddr((name, addr)) | ||
|
r9948 | def addressencode(ui, address, charsets=None, display=False): | ||
'''Turns address into RFC-2047 compliant header.''' | ||||
if display or not address: | ||||
return address or '' | ||||
name, addr = email.Utils.parseaddr(address) | ||||
return _addressencode(ui, name, addr, charsets) | ||||
def addrlistencode(ui, addrs, charsets=None, display=False): | ||||
'''Turns a list of addresses into a list of RFC-2047 compliant headers. | ||||
A single element of input list may contain multiple addresses, but output | ||||
always has one address per item''' | ||||
if display: | ||||
return [a.strip() for a in addrs if a.strip()] | ||||
result = [] | ||||
for name, addr in email.Utils.getaddresses(addrs): | ||||
if name or addr: | ||||
result.append(_addressencode(ui, name, addr, charsets)) | ||||
return result | ||||
|
r7114 | def mimeencode(ui, s, charsets=None, display=False): | ||
'''creates mime text object, encodes it if needed, and sets | ||||
charset and transfer-encoding accordingly.''' | ||||
cs = 'us-ascii' | ||||
if not display: | ||||
s, cs = _encode(ui, s, charsets) | ||||
|
r15562 | return mimetextqp(s, 'plain', cs) | ||
|
r28341 | |||
def headdecode(s): | ||||
'''Decodes RFC-2047 header''' | ||||
uparts = [] | ||||
|
r30072 | for part, charset in email.header.decode_header(s): | ||
|
r28341 | if charset is not None: | ||
try: | ||||
uparts.append(part.decode(charset)) | ||||
continue | ||||
except UnicodeDecodeError: | ||||
pass | ||||
try: | ||||
uparts.append(part.decode('UTF-8')) | ||||
continue | ||||
except UnicodeDecodeError: | ||||
pass | ||||
uparts.append(part.decode('ISO-8859-1')) | ||||
|
r31447 | return encoding.unitolocal(u' '.join(uparts)) | ||