|
1 # mail.py - mail sending bits for mercurial |
|
2 # |
|
3 # Copyright 2006 Matt Mackall <mpm@selenic.com> |
|
4 # |
|
5 # This software may be used and distributed according to the terms of the |
|
6 # GNU General Public License version 2 or any later version. |
|
7 |
|
8 from i18n import _ |
|
9 import util, encoding |
|
10 import os, smtplib, socket, quopri |
|
11 import email.Header, email.MIMEText, email.Utils |
|
12 |
|
13 _oldheaderinit = email.Header.Header.__init__ |
|
14 def _unifiedheaderinit(self, *args, **kw): |
|
15 """ |
|
16 Python2.7 introduces a backwards incompatible change |
|
17 (Python issue1974, r70772) in email.Generator.Generator code: |
|
18 pre-2.7 code passed "continuation_ws='\t'" to the Header |
|
19 constructor, and 2.7 removed this parameter. |
|
20 |
|
21 Default argument is continuation_ws=' ', which means that the |
|
22 behaviour is different in <2.7 and 2.7 |
|
23 |
|
24 We consider the 2.7 behaviour to be preferable, but need |
|
25 to have an unified behaviour for versions 2.4 to 2.7 |
|
26 """ |
|
27 # override continuation_ws |
|
28 kw['continuation_ws'] = ' ' |
|
29 _oldheaderinit(self, *args, **kw) |
|
30 |
|
31 email.Header.Header.__dict__['__init__'] = _unifiedheaderinit |
|
32 |
|
33 def _smtp(ui): |
|
34 '''build an smtp connection and return a function to send mail''' |
|
35 local_hostname = ui.config('smtp', 'local_hostname') |
|
36 s = smtplib.SMTP(local_hostname=local_hostname) |
|
37 mailhost = ui.config('smtp', 'host') |
|
38 if not mailhost: |
|
39 raise util.Abort(_('smtp.host not configured - cannot send mail')) |
|
40 mailport = util.getport(ui.config('smtp', 'port', 25)) |
|
41 ui.note(_('sending mail: smtp host %s, port %s\n') % |
|
42 (mailhost, mailport)) |
|
43 s.connect(host=mailhost, port=mailport) |
|
44 if ui.configbool('smtp', 'tls'): |
|
45 if not hasattr(socket, 'ssl'): |
|
46 raise util.Abort(_("can't use TLS: Python SSL support " |
|
47 "not installed")) |
|
48 ui.note(_('(using tls)\n')) |
|
49 s.ehlo() |
|
50 s.starttls() |
|
51 s.ehlo() |
|
52 username = ui.config('smtp', 'username') |
|
53 password = ui.config('smtp', 'password') |
|
54 if username and not password: |
|
55 password = ui.getpass() |
|
56 if username and password: |
|
57 ui.note(_('(authenticating to mail server as %s)\n') % |
|
58 (username)) |
|
59 try: |
|
60 s.login(username, password) |
|
61 except smtplib.SMTPException, inst: |
|
62 raise util.Abort(inst) |
|
63 |
|
64 def send(sender, recipients, msg): |
|
65 try: |
|
66 return s.sendmail(sender, recipients, msg) |
|
67 except smtplib.SMTPRecipientsRefused, inst: |
|
68 recipients = [r[1] for r in inst.recipients.values()] |
|
69 raise util.Abort('\n' + '\n'.join(recipients)) |
|
70 except smtplib.SMTPException, inst: |
|
71 raise util.Abort(inst) |
|
72 |
|
73 return send |
|
74 |
|
75 def _sendmail(ui, sender, recipients, msg): |
|
76 '''send mail using sendmail.''' |
|
77 program = ui.config('email', 'method') |
|
78 cmdline = '%s -f %s %s' % (program, util.email(sender), |
|
79 ' '.join(map(util.email, recipients))) |
|
80 ui.note(_('sending mail: %s\n') % cmdline) |
|
81 fp = util.popen(cmdline, 'w') |
|
82 fp.write(msg) |
|
83 ret = fp.close() |
|
84 if ret: |
|
85 raise util.Abort('%s %s' % ( |
|
86 os.path.basename(program.split(None, 1)[0]), |
|
87 util.explain_exit(ret)[0])) |
|
88 |
|
89 def connect(ui): |
|
90 '''make a mail connection. return a function to send mail. |
|
91 call as sendmail(sender, list-of-recipients, msg).''' |
|
92 if ui.config('email', 'method', 'smtp') == 'smtp': |
|
93 return _smtp(ui) |
|
94 return lambda s, r, m: _sendmail(ui, s, r, m) |
|
95 |
|
96 def sendmail(ui, sender, recipients, msg): |
|
97 send = connect(ui) |
|
98 return send(sender, recipients, msg) |
|
99 |
|
100 def validateconfig(ui): |
|
101 '''determine if we have enough config data to try sending email.''' |
|
102 method = ui.config('email', 'method', 'smtp') |
|
103 if method == 'smtp': |
|
104 if not ui.config('smtp', 'host'): |
|
105 raise util.Abort(_('smtp specified as email transport, ' |
|
106 'but no smtp host configured')) |
|
107 else: |
|
108 if not util.find_exe(method): |
|
109 raise util.Abort(_('%r specified as email transport, ' |
|
110 'but not in PATH') % method) |
|
111 |
|
112 def mimetextpatch(s, subtype='plain', display=False): |
|
113 '''If patch in utf-8 transfer-encode it.''' |
|
114 |
|
115 enc = None |
|
116 for line in s.splitlines(): |
|
117 if len(line) > 950: |
|
118 s = quopri.encodestring(s) |
|
119 enc = "quoted-printable" |
|
120 break |
|
121 |
|
122 cs = 'us-ascii' |
|
123 if not display: |
|
124 try: |
|
125 s.decode('us-ascii') |
|
126 except UnicodeDecodeError: |
|
127 try: |
|
128 s.decode('utf-8') |
|
129 cs = 'utf-8' |
|
130 except UnicodeDecodeError: |
|
131 # We'll go with us-ascii as a fallback. |
|
132 pass |
|
133 |
|
134 msg = email.MIMEText.MIMEText(s, subtype, cs) |
|
135 if enc: |
|
136 del msg['Content-Transfer-Encoding'] |
|
137 msg['Content-Transfer-Encoding'] = enc |
|
138 return msg |
|
139 |
|
140 def _charsets(ui): |
|
141 '''Obtains charsets to send mail parts not containing patches.''' |
|
142 charsets = [cs.lower() for cs in ui.configlist('email', 'charsets')] |
|
143 fallbacks = [encoding.fallbackencoding.lower(), |
|
144 encoding.encoding.lower(), 'utf-8'] |
|
145 for cs in fallbacks: # find unique charsets while keeping order |
|
146 if cs not in charsets: |
|
147 charsets.append(cs) |
|
148 return [cs for cs in charsets if not cs.endswith('ascii')] |
|
149 |
|
150 def _encode(ui, s, charsets): |
|
151 '''Returns (converted) string, charset tuple. |
|
152 Finds out best charset by cycling through sendcharsets in descending |
|
153 order. Tries both encoding and fallbackencoding for input. Only as |
|
154 last resort send as is in fake ascii. |
|
155 Caveat: Do not use for mail parts containing patches!''' |
|
156 try: |
|
157 s.decode('ascii') |
|
158 except UnicodeDecodeError: |
|
159 sendcharsets = charsets or _charsets(ui) |
|
160 for ics in (encoding.encoding, encoding.fallbackencoding): |
|
161 try: |
|
162 u = s.decode(ics) |
|
163 except UnicodeDecodeError: |
|
164 continue |
|
165 for ocs in sendcharsets: |
|
166 try: |
|
167 return u.encode(ocs), ocs |
|
168 except UnicodeEncodeError: |
|
169 pass |
|
170 except LookupError: |
|
171 ui.warn(_('ignoring invalid sendcharset: %s\n') % ocs) |
|
172 # if ascii, or all conversion attempts fail, send (broken) ascii |
|
173 return s, 'us-ascii' |
|
174 |
|
175 def headencode(ui, s, charsets=None, display=False): |
|
176 '''Returns RFC-2047 compliant header from given string.''' |
|
177 if not display: |
|
178 # split into words? |
|
179 s, cs = _encode(ui, s, charsets) |
|
180 return str(email.Header.Header(s, cs)) |
|
181 return s |
|
182 |
|
183 def _addressencode(ui, name, addr, charsets=None): |
|
184 name = headencode(ui, name, charsets) |
|
185 try: |
|
186 acc, dom = addr.split('@') |
|
187 acc = acc.encode('ascii') |
|
188 dom = dom.decode(encoding.encoding).encode('idna') |
|
189 addr = '%s@%s' % (acc, dom) |
|
190 except UnicodeDecodeError: |
|
191 raise util.Abort(_('invalid email address: %s') % addr) |
|
192 except ValueError: |
|
193 try: |
|
194 # too strict? |
|
195 addr = addr.encode('ascii') |
|
196 except UnicodeDecodeError: |
|
197 raise util.Abort(_('invalid local address: %s') % addr) |
|
198 return email.Utils.formataddr((name, addr)) |
|
199 |
|
200 def addressencode(ui, address, charsets=None, display=False): |
|
201 '''Turns address into RFC-2047 compliant header.''' |
|
202 if display or not address: |
|
203 return address or '' |
|
204 name, addr = email.Utils.parseaddr(address) |
|
205 return _addressencode(ui, name, addr, charsets) |
|
206 |
|
207 def addrlistencode(ui, addrs, charsets=None, display=False): |
|
208 '''Turns a list of addresses into a list of RFC-2047 compliant headers. |
|
209 A single element of input list may contain multiple addresses, but output |
|
210 always has one address per item''' |
|
211 if display: |
|
212 return [a.strip() for a in addrs if a.strip()] |
|
213 |
|
214 result = [] |
|
215 for name, addr in email.Utils.getaddresses(addrs): |
|
216 if name or addr: |
|
217 result.append(_addressencode(ui, name, addr, charsets)) |
|
218 return result |
|
219 |
|
220 def mimeencode(ui, s, charsets=None, display=False): |
|
221 '''creates mime text object, encodes it if needed, and sets |
|
222 charset and transfer-encoding accordingly.''' |
|
223 cs = 'us-ascii' |
|
224 if not display: |
|
225 s, cs = _encode(ui, s, charsets) |
|
226 return email.MIMEText.MIMEText(s, 'plain', cs) |