AppPkg/Applications/Python/Python-2.7.2/Lib/mimify.py

   1 #! /usr/bin/env python
   2
   3 """Mimification and unmimification of mail messages.
   4
   5 Decode quoted-printable parts of a mail message or encode using
   6 quoted-printable.
   7
   8 Usage:
   9         mimify(input, output)
  10         unmimify(input, output, decode_base64 = 0)
  11 to encode and decode respectively.  Input and output may be the name
  12 of a file or an open file object.  Only a readline() method is used
  13 on the input file, only a write() method is used on the output file.
  14 When using file names, the input and output file names may be the
  15 same.
  16
  17 Interactive usage:
  18         mimify.py -e [infile [outfile]]
  19         mimify.py -d [infile [outfile]]
  20 to encode and decode respectively.  Infile defaults to standard
  21 input and outfile to standard output.
  22 """
  23
  24 # Configure
  25 MAXLEN = 200    # if lines longer than this, encode as quoted-printable
  26 CHARSET = 'ISO-8859-1'  # default charset for non-US-ASCII mail
  27 QUOTE = '> '            # string replies are quoted with
  28 # End configure
  29
  30 import re
  31
  32 import warnings
  33 warnings.warn("the mimify module is deprecated; use the email package instead",
  34                 DeprecationWarning, 2)
  35
  36 __all__ = ["mimify","unmimify","mime_encode_header","mime_decode_header"]
  37
  38 qp = re.compile('^content-transfer-encoding:\\s*quoted-printable', re.I)
  39 base64_re = re.compile('^content-transfer-encoding:\\s*base64', re.I)
  40 mp = re.compile('^content-type:.*multipart/.*boundary="?([^;"\n]*)', re.I|re.S)
  41 chrset = re.compile('^(content-type:.*charset=")(us-ascii|iso-8859-[0-9]+)(".*)', re.I|re.S)
  42 he = re.compile('^-*\n')
  43 mime_code = re.compile('=([0-9a-f][0-9a-f])', re.I)
  44 mime_head = re.compile('=\\?iso-8859-1\\?q\\?([^? \t\n]+)\\?=', re.I)
  45 repl = re.compile('^subject:\\s+re: ', re.I)
  46
  47 class File:
  48     """A simple fake file object that knows about limited read-ahead and
  49     boundaries.  The only supported method is readline()."""
  50
  51     def __init__(self, file, boundary):
  52         self.file = file
  53         self.boundary = boundary
  54         self.peek = None
  55
  56     def readline(self):
  57         if self.peek is not None:
  58             return ''
  59         line = self.file.readline()
  60         if not line:
  61             return line
  62         if self.boundary:
  63             if line == self.boundary + '\n':
  64                 self.peek = line
  65                 return ''
  66             if line == self.boundary + '--\n':
  67                 self.peek = line
  68                 return ''
  69         return line
  70
  71 class HeaderFile:
  72     def __init__(self, file):
  73         self.file = file
  74         self.peek = None
  75
  76     def readline(self):
  77         if self.peek is not None:
  78             line = self.peek
  79             self.peek = None
  80         else:
  81             line = self.file.readline()
  82         if not line:
  83             return line
  84         if he.match(line):
  85             return line
  86         while 1:
  87             self.peek = self.file.readline()
  88             if len(self.peek) == 0 or \
  89                (self.peek[0] != ' ' and self.peek[0] != '\t'):
  90                 return line
  91             line = line + self.peek
  92             self.peek = None
  93
  94 def mime_decode(line):
  95     """Decode a single line of quoted-printable text to 8bit."""
  96     newline = ''
  97     pos = 0
  98     while 1:
  99         res = mime_code.search(line, pos)
 100         if res is None:
 101             break
 102         newline = newline + line[pos:res.start(0)] + \
 103                   chr(int(res.group(1), 16))
 104         pos = res.end(0)
 105     return newline + line[pos:]
 106
 107 def mime_decode_header(line):
 108     """Decode a header line to 8bit."""
 109     newline = ''
 110     pos = 0
 111     while 1:
 112         res = mime_head.search(line, pos)
 113         if res is None:
 114             break
 115         match = res.group(1)
 116         # convert underscores to spaces (before =XX conversion!)
 117         match = ' '.join(match.split('_'))
 118         newline = newline + line[pos:res.start(0)] + mime_decode(match)
 119         pos = res.end(0)
 120     return newline + line[pos:]
 121
 122 def unmimify_part(ifile, ofile, decode_base64 = 0):
 123     """Convert a quoted-printable part of a MIME mail message to 8bit."""
 124     multipart = None
 125     quoted_printable = 0
 126     is_base64 = 0
 127     is_repl = 0
 128     if ifile.boundary and ifile.boundary[:2] == QUOTE:
 129         prefix = QUOTE
 130     else:
 131         prefix = ''
 132
 133     # read header
 134     hfile = HeaderFile(ifile)
 135     while 1:
 136         line = hfile.readline()
 137         if not line:
 138             return
 139         if prefix and line[:len(prefix)] == prefix:
 140             line = line[len(prefix):]
 141             pref = prefix
 142         else:
 143             pref = ''
 144         line = mime_decode_header(line)
 145         if qp.match(line):
 146             quoted_printable = 1
 147             continue        # skip this header
 148         if decode_base64 and base64_re.match(line):
 149             is_base64 = 1
 150             continue
 151         ofile.write(pref + line)
 152         if not prefix and repl.match(line):
 153             # we're dealing with a reply message
 154             is_repl = 1
 155         mp_res = mp.match(line)
 156         if mp_res:
 157             multipart = '--' + mp_res.group(1)
 158         if he.match(line):
 159             break
 160     if is_repl and (quoted_printable or multipart):
 161         is_repl = 0
 162
 163     # read body
 164     while 1:
 165         line = ifile.readline()
 166         if not line:
 167             return
 168         line = re.sub(mime_head, '\\1', line)
 169         if prefix and line[:len(prefix)] == prefix:
 170             line = line[len(prefix):]
 171             pref = prefix
 172         else:
 173             pref = ''
 174 ##              if is_repl and len(line) >= 4 and line[:4] == QUOTE+'--' and line[-3:] != '--\n':
 175 ##                      multipart = line[:-1]
 176         while multipart:
 177             if line == multipart + '--\n':
 178                 ofile.write(pref + line)
 179                 multipart = None
 180                 line = None
 181                 break
 182             if line == multipart + '\n':
 183                 ofile.write(pref + line)
 184                 nifile = File(ifile, multipart)
 185                 unmimify_part(nifile, ofile, decode_base64)
 186                 line = nifile.peek
 187                 if not line:
 188                     # premature end of file
 189                     break
 190                 continue
 191             # not a boundary between parts
 192             break
 193         if line and quoted_printable:
 194             while line[-2:] == '=\n':
 195                 line = line[:-2]
 196                 newline = ifile.readline()
 197                 if newline[:len(QUOTE)] == QUOTE:
 198                     newline = newline[len(QUOTE):]
 199                 line = line + newline
 200             line = mime_decode(line)
 201         if line and is_base64 and not pref:
 202             import base64
 203             line = base64.decodestring(line)
 204         if line:
 205             ofile.write(pref + line)
 206
 207 def unmimify(infile, outfile, decode_base64 = 0):
 208     """Convert quoted-printable parts of a MIME mail message to 8bit."""
 209     if type(infile) == type(''):
 210         ifile = open(infile)
 211         if type(outfile) == type('') and infile == outfile:
 212             import os
 213             d, f = os.path.split(infile)
 214             os.rename(infile, os.path.join(d, ',' + f))
 215     else:
 216         ifile = infile
 217     if type(outfile) == type(''):
 218         ofile = open(outfile, 'w')
 219     else:
 220         ofile = outfile
 221     nifile = File(ifile, None)
 222     unmimify_part(nifile, ofile, decode_base64)
 223     ofile.flush()
 224
 225 mime_char = re.compile('[=\177-\377]') # quote these chars in body
 226 mime_header_char = re.compile('[=?\177-\377]') # quote these in header
 227
 228 def mime_encode(line, header):
 229     """Code a single line as quoted-printable.
 230     If header is set, quote some extra characters."""
 231     if header:
 232         reg = mime_header_char
 233     else:
 234         reg = mime_char
 235     newline = ''
 236     pos = 0
 237     if len(line) >= 5 and line[:5] == 'From ':
 238         # quote 'From ' at the start of a line for stupid mailers
 239         newline = ('=%02x' % ord('F')).upper()
 240         pos = 1
 241     while 1:
 242         res = reg.search(line, pos)
 243         if res is None:
 244             break
 245         newline = newline + line[pos:res.start(0)] + \
 246                   ('=%02x' % ord(res.group(0))).upper()
 247         pos = res.end(0)
 248     line = newline + line[pos:]
 249
 250     newline = ''
 251     while len(line) >= 75:
 252         i = 73
 253         while line[i] == '=' or line[i-1] == '=':
 254             i = i - 1
 255         i = i + 1
 256         newline = newline + line[:i] + '=\n'
 257         line = line[i:]
 258     return newline + line
 259
 260 mime_header = re.compile('([ \t(]|^)([-a-zA-Z0-9_+]*[\177-\377][-a-zA-Z0-9_+\177-\377]*)(?=[ \t)]|\n)')
 261
 262 def mime_encode_header(line):
 263     """Code a single header line as quoted-printable."""
 264     newline = ''
 265     pos = 0
 266     while 1:
 267         res = mime_header.search(line, pos)
 268         if res is None:
 269             break
 270         newline = '%s%s%s=?%s?Q?%s?=' % \
 271                   (newline, line[pos:res.start(0)], res.group(1),
 272                    CHARSET, mime_encode(res.group(2), 1))
 273         pos = res.end(0)
 274     return newline + line[pos:]
 275
 276 mv = re.compile('^mime-version:', re.I)
 277 cte = re.compile('^content-transfer-encoding:', re.I)
 278 iso_char = re.compile('[\177-\377]')
 279
 280 def mimify_part(ifile, ofile, is_mime):
 281     """Convert an 8bit part of a MIME mail message to quoted-printable."""
 282     has_cte = is_qp = is_base64 = 0
 283     multipart = None
 284     must_quote_body = must_quote_header = has_iso_chars = 0
 285
 286     header = []
 287     header_end = ''
 288     message = []
 289     message_end = ''
 290     # read header
 291     hfile = HeaderFile(ifile)
 292     while 1:
 293         line = hfile.readline()
 294         if not line:
 295             break
 296         if not must_quote_header and iso_char.search(line):
 297             must_quote_header = 1
 298         if mv.match(line):
 299             is_mime = 1
 300         if cte.match(line):
 301             has_cte = 1
 302             if qp.match(line):
 303                 is_qp = 1
 304             elif base64_re.match(line):
 305                 is_base64 = 1
 306         mp_res = mp.match(line)
 307         if mp_res:
 308             multipart = '--' + mp_res.group(1)
 309         if he.match(line):
 310             header_end = line
 311             break
 312         header.append(line)
 313
 314     # read body
 315     while 1:
 316         line = ifile.readline()
 317         if not line:
 318             break
 319         if multipart:
 320             if line == multipart + '--\n':
 321                 message_end = line
 322                 break
 323             if line == multipart + '\n':
 324                 message_end = line
 325                 break
 326         if is_base64:
 327             message.append(line)
 328             continue
 329         if is_qp:
 330             while line[-2:] == '=\n':
 331                 line = line[:-2]
 332                 newline = ifile.readline()
 333                 if newline[:len(QUOTE)] == QUOTE:
 334                     newline = newline[len(QUOTE):]
 335                 line = line + newline
 336             line = mime_decode(line)
 337         message.append(line)
 338         if not has_iso_chars:
 339             if iso_char.search(line):
 340                 has_iso_chars = must_quote_body = 1
 341         if not must_quote_body:
 342             if len(line) > MAXLEN:
 343                 must_quote_body = 1
 344
 345     # convert and output header and body
 346     for line in header:
 347         if must_quote_header:
 348             line = mime_encode_header(line)
 349         chrset_res = chrset.match(line)
 350         if chrset_res:
 351             if has_iso_chars:
 352                 # change us-ascii into iso-8859-1
 353                 if chrset_res.group(2).lower() == 'us-ascii':
 354                     line = '%s%s%s' % (chrset_res.group(1),
 355                                        CHARSET,
 356                                        chrset_res.group(3))
 357             else:
 358                 # change iso-8859-* into us-ascii
 359                 line = '%sus-ascii%s' % chrset_res.group(1, 3)
 360         if has_cte and cte.match(line):
 361             line = 'Content-Transfer-Encoding: '
 362             if is_base64:
 363                 line = line + 'base64\n'
 364             elif must_quote_body:
 365                 line = line + 'quoted-printable\n'
 366             else:
 367                 line = line + '7bit\n'
 368         ofile.write(line)
 369     if (must_quote_header or must_quote_body) and not is_mime:
 370         ofile.write('Mime-Version: 1.0\n')
 371         ofile.write('Content-Type: text/plain; ')
 372         if has_iso_chars:
 373             ofile.write('charset="%s"\n' % CHARSET)
 374         else:
 375             ofile.write('charset="us-ascii"\n')
 376     if must_quote_body and not has_cte:
 377         ofile.write('Content-Transfer-Encoding: quoted-printable\n')
 378     ofile.write(header_end)
 379
 380     for line in message:
 381         if must_quote_body:
 382             line = mime_encode(line, 0)
 383         ofile.write(line)
 384     ofile.write(message_end)
 385
 386     line = message_end
 387     while multipart:
 388         if line == multipart + '--\n':
 389             # read bit after the end of the last part
 390             while 1:
 391                 line = ifile.readline()
 392                 if not line:
 393                     return
 394                 if must_quote_body:
 395                     line = mime_encode(line, 0)
 396                 ofile.write(line)
 397         if line == multipart + '\n':
 398             nifile = File(ifile, multipart)
 399             mimify_part(nifile, ofile, 1)
 400             line = nifile.peek
 401             if not line:
 402                 # premature end of file
 403                 break
 404             ofile.write(line)
 405             continue
 406         # unexpectedly no multipart separator--copy rest of file
 407         while 1:
 408             line = ifile.readline()
 409             if not line:
 410                 return
 411             if must_quote_body:
 412                 line = mime_encode(line, 0)
 413             ofile.write(line)
 414
 415 def mimify(infile, outfile):
 416     """Convert 8bit parts of a MIME mail message to quoted-printable."""
 417     if type(infile) == type(''):
 418         ifile = open(infile)
 419         if type(outfile) == type('') and infile == outfile:
 420             import os
 421             d, f = os.path.split(infile)
 422             os.rename(infile, os.path.join(d, ',' + f))
 423     else:
 424         ifile = infile
 425     if type(outfile) == type(''):
 426         ofile = open(outfile, 'w')
 427     else:
 428         ofile = outfile
 429     nifile = File(ifile, None)
 430     mimify_part(nifile, ofile, 0)
 431     ofile.flush()
 432
 433 import sys
 434 if __name__ == '__main__' or (len(sys.argv) > 0 and sys.argv[0] == 'mimify'):
 435     import getopt
 436     usage = 'Usage: mimify [-l len] -[ed] [infile [outfile]]'
 437
 438     decode_base64 = 0
 439     opts, args = getopt.getopt(sys.argv[1:], 'l:edb')
 440     if len(args) not in (0, 1, 2):
 441         print usage
 442         sys.exit(1)
 443     if (('-e', '') in opts) == (('-d', '') in opts) or \
 444        ((('-b', '') in opts) and (('-d', '') not in opts)):
 445         print usage
 446         sys.exit(1)
 447     for o, a in opts:
 448         if o == '-e':
 449             encode = mimify
 450         elif o == '-d':
 451             encode = unmimify
 452         elif o == '-l':
 453             try:
 454                 MAXLEN = int(a)
 455             except (ValueError, OverflowError):
 456                 print usage
 457                 sys.exit(1)
 458         elif o == '-b':
 459             decode_base64 = 1
 460     if len(args) == 0:
 461         encode_args = (sys.stdin, sys.stdout)
 462     elif len(args) == 1:
 463         encode_args = (args[0], sys.stdout)
 464     else:
 465         encode_args = (args[0], args[1])
 466     if decode_base64:
 467         encode_args = encode_args + (decode_base64,)
 468     encode(*encode_args)