| 1
28
29 __all__ = [
30 'body_decode',
31 'body_encode',
32 'body_quopri_check',
33 'body_quopri_len',
34 'decode',
35 'decodestring',
36 'encode',
37 'encodestring',
38 'header_decode',
39 'header_encode',
40 'header_quopri_check',
41 'header_quopri_len',
42 'quote',
43 'unquote',
44 ]
45
46 import re
47
48 from string import hexdigits
49 from email.utils import fix_eols
50
51 CRLF = '\r\n'
52 NL = '\n'
53
54 = 7
56
57 hqre = re.compile(r'[^-a-zA-Z0-9!*+/ ]')
58 bqre = re.compile(r'[^ !-<>-~\t]')
59
60
61
62 header_quopri_check(c):
64 """Return True if the character should be escaped with header quopri."""
65 return bool(hqre.match(c))
66
67
68 def body_quopri_check(c):
69 """Return True if the character should be escaped with body quopri."""
70 return bool(bqre.match(c))
71
72
73 def header_quopri_len(s):
74 """Return the length of str when it is encoded with header quopri."""
75 count = 0
76 for c in s:
77 if hqre.match(c):
78 count += 3
79 else:
80 count += 1
81 return count
82
83
84 def body_quopri_len(str):
85 """Return the length of str when it is encoded with body quopri."""
86 count = 0
87 for c in str:
88 if bqre.match(c):
89 count += 3
90 else:
91 count += 1
92 return count
93
94
95 def _max_append(L, s, maxlen, extra=''):
96 if not L:
97 L.append(s.lstrip())
98 elif len(L[-1]) + len(s) <= maxlen:
99 L[-1] += extra + s
100 else:
101 L.append(s.lstrip())
102
103
104 def unquote(s):
105 """Turn a string in the form =AB to the ASCII character with value 0xab"""
106 return chr(int(s[1:3], 16))
107
108
109 def quote(c):
110 return "=%02X" % ord(c)
111
112
113
114 def header_encode(header, charset="iso-8859-1", keep_eols=False,
115 maxlinelen=76, eol=NL):
116 """Encode a single header line with quoted-printable (like) encoding.
117
118 Defined in RFC 2045, this `Q' encoding is similar to quoted-printable, but
119 used specifically for email header fields to allow charsets with mostly 7
120 bit characters (and some 8 bit) to remain more or less readable in non-RFC
121 2045 aware mail clients.
122
123 charset names the character set to use to encode the header. It defaults
124 to iso-8859-1.
125
126 The resulting string will be in the form:
127
128 "=?charset?q?I_f=E2rt_in_your_g=E8n=E8ral_dire=E7tion?\\n
129 =?charset?q?Silly_=C8nglish_Kn=EEghts?="
130
131 with each line wrapped safely at, at most, maxlinelen characters (defaults
132 to 76 characters). If maxlinelen is None, the entire string is encoded in
133 one chunk with no splitting.
134
135 End-of-line characters (\\r, \\n, \\r\\n) will be automatically converted
136 to the canonical email line separator \\r\\n unless the keep_eols
137 parameter is True (the default is False).
138
139 Each line of the header will be terminated in the value of eol, which
140 defaults to "\\n". Set this to "\\r\\n" if you are using the result of
141 this function directly in email.
142 """
143 if not header:
145 return header
146
147 if not keep_eols:
148 header = fix_eols(header)
149
150 quoted = []
153 if maxlinelen is None:
154 max_encoded = 100000
156 else:
157 max_encoded = maxlinelen - len(charset) - MISC_LEN - 1
158
159 for c in header:
160 if c == ' ':
162 _max_append(quoted, '_', max_encoded)
163 elif not hqre.match(c):
165 _max_append(quoted, c, max_encoded)
166 else:
168 _max_append(quoted, "=%02X" % ord(c), max_encoded)
169
170 joiner = eol + ' '
174 return joiner.join(['=?%s?q?%s?=' % (charset, line) for line in quoted])
175
176
177
178 def encode(body, binary=False, maxlinelen=76, eol=NL):
179 """Encode with quoted-printable, wrapping at maxlinelen characters.
180
181 If binary is False (the default), end-of-line characters will be converted
182 to the canonical email end-of-line sequence \\r\\n. Otherwise they will
183 be left verbatim.
184
185 Each line of encoded text will end with eol, which defaults to "\\n". Set
186 this to "\\r\\n" if you will be using the result of this function directly
187 in an email.
188
189 Each line will be wrapped at, at most, maxlinelen characters (defaults to
190 76 characters). Long lines will have the `soft linefeed' quoted-printable
191 character "=" appended to them, so the decoded text will be identical to
192 the original text.
193 """
194 if not body:
195 return body
196
197 if not binary:
198 body = fix_eols(body)
199
200 encoded_body = ''
204 lineno = -1
205 lines = body.splitlines(1)
208 for line in lines:
209 if line.endswith(CRLF):
211 line = line[:-2]
212 elif line[-1] in CRLF:
213 line = line[:-1]
214
215 lineno += 1
216 encoded_line = ''
217 prev = None
218 linelen = len(line)
219 for j in range(linelen):
222 c = line[j]
223 prev = c
224 if bqre.match(c):
225 c = quote(c)
226 elif j+1 == linelen:
227 if c not in ' \t':
229 encoded_line += c
230 prev = c
231 continue
232 if len(encoded_line) + len(c) >= maxlinelen:
234 encoded_body += encoded_line + '=' + eol
235 encoded_line = ''
236 encoded_line += c
237 if prev and prev in ' \t':
239 if lineno + 1 == len(lines):
241 prev = quote(prev)
242 if len(encoded_line) + len(prev) > maxlinelen:
243 encoded_body += encoded_line + '=' + eol + prev
244 else:
245 encoded_body += encoded_line + prev
246 else:
248 encoded_body += encoded_line + prev + '=' + eol
249 encoded_line = ''
250 if lines[lineno].endswith(CRLF) or lines[lineno][-1] in CRLF:
253 encoded_body += encoded_line + eol
254 else:
255 encoded_body += encoded_line
256 encoded_line = ''
257 return encoded_body
258
259
260 body_encode = encode
262 encodestring = encode
263
264
265
266 def decode(encoded, eol=NL):
269 """Decode a quoted-printable string.
270
271 Lines are separated with eol, which defaults to \\n.
272 """
273 if not encoded:
274 return encoded
275 decoded = ''
279
280 for line in encoded.splitlines():
281 line = line.rstrip()
282 if not line:
283 decoded += eol
284 continue
285
286 i = 0
287 n = len(line)
288 while i < n:
289 c = line[i]
290 if c <> '=':
291 decoded += c
292 i += 1
293 elif i+1 == n:
296 i += 1
297 continue
298 elif i+2 < n and line[i+1] in hexdigits and line[i+2] in hexdigits:
300 decoded += unquote(line[i:i+3])
301 i += 3
302 else:
304 decoded += c
305 i += 1
306
307 if i == n:
308 decoded += eol
309 if not encoded.endswith(eol) and decoded.endswith(eol):
311 decoded = decoded[:-1]
312 return decoded
313
314
315 body_decode = decode
317 decodestring = decode
318
319
320
321 def _unquote_match(match):
322 """Turn a match in the form =AB to the ASCII character with value 0xab"""
323 s = match.group(0)
324 return unquote(s)
325
326
327 header_decode(s):
329 """Decode a string encoded with RFC 2045 MIME header `Q' encoding.
330
331 This function does not parse a full MIME header value encoded with
332 quoted-printable (like =?iso-8895-1?q?Hello_World?=) -- please use
333 the high level email.Header class for that functionality.
334 """
335 s = s.replace('_', ' ')
336 return re.sub(r'=\w{2}', _unquote_match, s)
|