mimedecode.py

   1 #! /usr/bin/env python
   2 """Decode MIME message"""
   3
   4
   5 from mimedecode_version import __version__, __author__, __copyright__, __license__
   6
   7
   8 import sys, os
   9 import email
  10
  11 try:
  12     from cStringIO import StringIO
  13 except ImportError:
  14     from StringIO import StringIO
  15
  16
  17 import socket
  18 host_name = socket.gethostname()
  19
  20 me = os.path.basename(sys.argv[0])
  21
  22
  23 def version(exit=1):
  24     sys.stdout.write("""\
  25 Broytman mimedecode.py version %s, %s
  26 """ % (__version__, __copyright__))
  27     if exit: sys.exit(0)
  28
  29
  30 def usage(code=0):
  31     version(0)
  32     sys.stdout.write("""\
  33 Usage: %s [-h|--help] [-V|--version] [-cCDP] [-f charset] [-d header] [-p header:param] [-beit mask] [filename]
  34 """ % me)
  35     sys.exit(code)
  36
  37
  38 def output(s, outfile=sys.stdout):
  39     outfile.write(s)
  40
  41 def output_headers(msg, outfile=sys.stdout):
  42     unix_from = msg.get_unixfrom()
  43     if unix_from:
  44         output(unix_from + '\n')
  45     for key, value in msg.items():
  46         output("%s: %s\n" % (key, value), outfile)
  47     output("\n", outfile) # End of headers
  48
  49
  50 def recode(s, charset):
  51     return unicode(s, charset, "replace").encode(gopts.default_encoding, "replace")
  52
  53
  54 def recode2(s, charset):
  55     if charset and charset.lower() <> gopts.default_encoding:
  56         s = recode(s, charset)
  57     return s
  58
  59
  60 def _decode_header(s):
  61     """Return a decoded string according to RFC 2047.
  62     NOTE: This is almost the same as email.Utils.decode.
  63     """
  64     from types import ListType
  65     import email.Header
  66
  67     L = email.Header.decode_header(s)
  68     if not isinstance(L, ListType):
  69         # s wasn't decoded
  70         return s
  71
  72     rtn = []
  73     for atom, charset in L:
  74         if charset is None:
  75             rtn.append(atom)
  76         else:
  77             rtn.append(recode2(atom, charset))
  78         rtn.append(' ')
  79     del rtn[-1] # remove the last space
  80
  81     # Now that we've decoded everything, we just need to join all the parts
  82     # together into the final string.
  83     return ''.join(rtn)
  84
  85
  86 def decode_header(msg, header):
  87     "Decode mail header (if exists) and put it back, if it was encoded"
  88
  89     if msg.has_key(header):
  90         value = msg[header]
  91         new_value = _decode_header(value)
  92         if new_value <> value: # do not bother to touch msg if not changed
  93             set_header(msg, header, new_value)
  94
  95
  96 def _decode_header_param(s):
  97     return recode2(s[2], s[0])
  98
  99
 100 def decode_header_param(msg, header, param):
 101     "Decode mail header's parameter (if exists) and put it back, if it was encoded"
 102
 103     if msg.has_key(header):
 104         value = msg.get_param(param, header=header)
 105         if value:
 106             from types import TupleType
 107             if isinstance(value, TupleType):
 108                 new_value = _decode_header_param(value)
 109             else:
 110                 new_value = _decode_header(value)
 111             if new_value <> value: # do not bother to touch msg if not changed
 112                 msg.set_param(param, new_value, header)
 113
 114
 115 def decode_headers(msg):
 116     "Decode message headers according to global options"
 117
 118     for header in gopts.decode_headers:
 119         decode_header(msg, header)
 120
 121     for header, param in gopts.decode_header_params:
 122         decode_header_param(msg, header, param)
 123
 124
 125 def set_header(msg, header, value):
 126     "Replace header"
 127
 128     if msg.has_key(header):
 129         msg.replace_header(header, value)
 130     else:
 131         msg[header] = value
 132
 133
 134 def set_content_type(msg, newtype, charset=None):
 135     msg.set_type(newtype)
 136
 137     if charset:
 138         msg.set_param("charset", charset, "Content-Type")
 139
 140
 141
 142 caps = None # Globally stored mailcap database; initialized only if needed
 143
 144 def decode_body(msg, s):
 145     "Decode body to plain text using first copiousoutput filter from mailcap"
 146
 147     import mailcap, tempfile
 148
 149     global caps
 150     if caps is None:
 151         caps = mailcap.getcaps()
 152
 153     content_type = msg.get_content_type()
 154     filename = tempfile.mktemp()
 155     command = None
 156
 157     entries = mailcap.lookup(caps, content_type, "view")
 158     for entry in entries:
 159         if entry.has_key('copiousoutput'):
 160             if entry.has_key('test'):
 161                 test = mailcap.subst(entry['test'], content_type, filename)
 162                 if test and os.system(test) != 0:
 163                     continue
 164             command = mailcap.subst(entry["view"], content_type, filename)
 165             break
 166
 167     if not command:
 168         return s
 169
 170     file = open(filename, 'w')
 171     file.write(s)
 172     file.close()
 173
 174     pipe = os.popen(command, 'r')
 175     s = pipe.read()
 176     pipe.close()
 177     os.remove(filename)
 178
 179     set_content_type(msg, "text/plain")
 180     msg["X-MIME-Autoconverted"] = "from %s to text/plain by %s id %s" % (content_type, host_name, command.split()[0])
 181
 182     return s
 183
 184
 185 def recode_charset(msg, s):
 186     "Recode charset of the message to the default charset"
 187
 188     save_charset = charset = msg.get_content_charset()
 189     if charset and charset.lower() <> gopts.default_encoding:
 190         s = recode2(s, charset)
 191         content_type = msg.get_content_type()
 192         set_content_type(msg, content_type, gopts.default_encoding)
 193         msg["X-MIME-Autoconverted"] = "from %s to %s by %s id %s" % (save_charset, gopts.default_encoding, host_name, me)
 194     return s
 195
 196
 197 def totext(msg, instring):
 198     "Convert instring content to text"
 199
 200     if msg.is_multipart(): # Recursively decode all parts of the multipart message
 201         newfile = StringIO(str(msg))
 202         newfile.seek(0)
 203         decode_file(newfile)
 204         return
 205
 206     # Decode body and recode charset
 207     s = decode_body(msg, instring)
 208     if gopts.recode_charset:
 209         s = recode_charset(msg, s)
 210
 211     output_headers(msg)
 212     output(s)
 213
 214
 215 def decode_part(msg):
 216     "Decode one part of the message"
 217
 218     decode_headers(msg)
 219     encoding = msg["Content-Transfer-Encoding"]
 220
 221     if encoding in (None, '', '7bit', '8bit', 'binary'):
 222         outstring = str(msg.get_payload())
 223     else: # Decode from transfer ecoding to text or binary form
 224         outstring = str(msg.get_payload(decode=1))
 225         set_header(msg, "Content-Transfer-Encoding", "8bit")
 226         msg["X-MIME-Autoconverted"] = "from %s to 8bit by %s id %s" % (encoding, host_name, me)
 227
 228     # Test all mask lists and find what to do with this content type
 229     masks = []
 230     ctype = msg.get_content_type()
 231     if ctype:
 232         masks.append(ctype)
 233     mtype = msg.get_content_maintype()
 234     if mtype:
 235         masks.append(mtype + '/*')
 236     masks.append('*/*')
 237
 238     for content_type in masks:
 239         if content_type in gopts.totext_mask:
 240             totext(msg, outstring)
 241             return
 242         elif content_type in gopts.binary_mask:
 243             output_headers(msg)
 244             output(outstring)
 245             return
 246         elif content_type in gopts.ignore_mask:
 247             output_headers(msg)
 248             output("\nMessage body of type `%s' skipped.\n" % content_type)
 249             return
 250         elif content_type in gopts.error_mask:
 251             raise ValueError, "content type `%s' prohibited" % content_type
 252
 253     # Neither content type nor masks were listed - decode by default
 254     totext(msg, outstring)
 255
 256
 257 def decode_file(infile):
 258     "Decode the entire message"
 259
 260     msg = email.message_from_file(infile)
 261     boundary = msg.get_boundary()
 262
 263     if msg.is_multipart():
 264         decode_headers(msg)
 265         output_headers(msg)
 266
 267         if msg.preamble: # Preserve the first part, it is probably not a RFC822-message
 268             output(msg.preamble) # Usually it is just a few lines of text (MIME warning)
 269
 270         for subpart in msg.get_payload():
 271             output("\n--%s\n" % boundary)
 272             decode_part(subpart)
 273
 274         output("\n--%s--\n" % boundary)
 275
 276         if msg.epilogue:
 277             output(msg.epilogue)
 278
 279     else:
 280         if msg.has_key("Content-Type"): # Simple one-part message - decode it
 281             decode_part(msg)
 282
 283         else: # Not a message, just text - copy it literally
 284             output(str(msg))
 285
 286
 287 class GlobalOptions:
 288     from m_lib.defenc import default_encoding
 289     recode_charset = 1 # recode charset of message body
 290
 291     decode_headers = ["From", "Subject"] # A list of headers to decode
 292     decode_header_params = [
 293         ("Content-Type", "name"),
 294         ("Content-Disposition", "filename"),
 295     ] # A list of headers' parameters to decode
 296
 297     totext_mask = [] # A list of content-types to decode
 298     binary_mask = [] # A list to pass through
 299     ignore_mask = [] # Ignore (skip, do not decode and do not include into output)
 300     error_mask = []  # Raise error if encounter one of these
 301
 302 gopts = GlobalOptions
 303
 304
 305 def init():
 306     from getopt import getopt, GetoptError
 307
 308     try:
 309         options, arguments = getopt(sys.argv[1:], 'hVcCDPf:d:p:b:e:i:t:',
 310             ['help', 'version'])
 311     except GetoptError:
 312         usage(1)
 313
 314     for option, value in options:
 315         if option == '-h':
 316             usage()
 317         elif option == '--help':
 318             usage()
 319         elif option == '-V':
 320             version()
 321         elif option == '--version':
 322             version()
 323         elif option == '-c':
 324             gopts.recode_charset = 1
 325         elif option == '-C':
 326             gopts.recode_charset = 0
 327         elif option == '-f':
 328             gopts.default_encoding = value
 329         elif option == '-d':
 330             gopts.decode_headers.append(value)
 331         elif option == '-D':
 332             gopts.decode_headers = []
 333         elif option == '-p':
 334             gopts.decode_header_params.append(value.split(':', 1))
 335         elif option == '-P':
 336             gopts.decode_header_params = []
 337         elif option == '-t':
 338             gopts.totext_mask.append(value)
 339         elif option == '-b':
 340             gopts.binary_mask.append(value)
 341         elif option == '-i':
 342             gopts.ignore_mask.append(value)
 343         elif option == '-e':
 344             gopts.error_mask.append(value)
 345         else:
 346             usage(1)
 347
 348     return arguments
 349
 350
 351 if __name__ == "__main__":
 352     arguments = init()
 353
 354     la = len(arguments)
 355     if la >= 2:
 356         usage(1)
 357     if (la == 0) or (arguments[0] == '-'):
 358         infile = sys.stdin
 359     else:
 360         infile = open(arguments[0], 'r')
 361
 362     decode_file(infile)