mimedecode.py

   1 #! /usr/bin/env python
   2 """Decode MIME message"""
   3
   4 import os
   5 import subprocess
   6 import sys
   7
   8 from mimedecode_version import __version__, __copyright__
   9
  10 if sys.version_info[0] >= 3:
  11     # Replace email.message._formatparam with _formatparam from Python 2.7
  12     # to avoid re-encoding non-ascii params.
  13     import formatparam_27  # noqa: F401: Imported for its side effect
  14
  15 me = os.path.basename(sys.argv[0])
  16
  17
  18 def version(exit=1):
  19     sys.stdout.write("""\
  20 Broytman mimedecode.py version %s, %s
  21 """ % (__version__, __copyright__))
  22     if exit:
  23         sys.exit(0)
  24
  25
  26 def usage(code=0, errormsg=''):
  27     version(0)
  28     sys.stdout.write("""\
  29 Usage: %s [-h|--help] [-V|--version] [-cCDP] [-H|--host=hostname] [-f charset] [-d header1[,h2,...]|*[,-h1,...]] [-p header1[,h2,h3,...]:param1[,p2,p3,...]] [-r header1[,h2,...]|*[,-h1,...]] [-R header1[,h2,h3,...]:param1[,p2,p3,...]] [--set-header header:value] [--set-param header:param=value] [-Bbeit mask] [--save-headers|body|message mask] [-O dest_dir] [-o output_file] [input_file [output_file]]
  30 """ % me)  # noqa: E501
  31     if errormsg:
  32         sys.stderr.write(errormsg + os.linesep)
  33     sys.exit(code)
  34
  35
  36 def output_headers(msg):
  37     unix_from = msg.get_unixfrom()
  38     if unix_from:
  39         output(unix_from)
  40         output(os.linesep)
  41     for key, value in msg.items():
  42         output(key)
  43         output(": ")
  44         value = value.split(';', 1)
  45         output(value[0])
  46         if len(value) == 2:
  47             output(";")
  48             output(_decode_header(value[1], strip=False))
  49         output(os.linesep)
  50     output(os.linesep)  # End of headers
  51
  52
  53 def recode_if_needed(s, charset):
  54     if bytes is str:  # Python2
  55         if isinstance(s, bytes) and \
  56                 charset and charset.lower() != g.default_encoding:
  57             s = s.decode(charset, "replace").\
  58                 encode(g.default_encoding, "replace")
  59     else:  # Python3
  60         if isinstance(s, bytes):
  61             s = s.decode(charset, "replace")
  62     return s
  63
  64
  65 def _decode_header(s, strip=True):
  66     """Return a decoded string according to RFC 2047.
  67     NOTE: This is almost the same as email.Utils.decode.
  68     """
  69     import email.header
  70
  71     L = email.header.decode_header(s)
  72     if not isinstance(L, list):
  73         # s wasn't decoded
  74         return s
  75
  76     rtn = []
  77     for atom, charset in L:
  78         atom = recode_if_needed(atom, charset or g.default_encoding)
  79         if strip:
  80             atom = atom.strip()
  81         rtn.append(atom)
  82
  83     # Now that we've decoded everything, we just need to join all the parts
  84     # together into the final string.
  85     return ' '.join(rtn)
  86
  87
  88 def decode_header(msg, header):
  89     "Decode mail header (if exists) and put it back, if it was encoded"
  90
  91     if header in msg:
  92         value = msg[header]
  93         new_value = _decode_header(value)
  94         if new_value != value:  # do not bother to touch msg if not changed
  95             set_header(msg, header, new_value)
  96
  97
  98 def decode_header_param(msg, header, param):
  99     """Decode mail header's parameter
 100
 101     Decode mail header's parameter (if exists)
 102     and put it back if it was encoded.
 103     """
 104     if header in msg:
 105         value = msg.get_param(param, header=header)
 106         if value:
 107             if isinstance(value, tuple):
 108                 new_value = recode_if_needed(value[2], value[0])
 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 _get_exceptions(list):
 116     return [x[1:].lower() for x in list[1:] if x[0] == '-']
 117
 118
 119 def _decode_headers_params(msg, header, decode_all_params, param_list):
 120     if decode_all_params:
 121         params = msg.get_params(header=header)
 122         if params:
 123             for param, value in params:
 124                 if param not in param_list:
 125                     decode_header_param(msg, header, param)
 126     else:
 127         for param in param_list:
 128             decode_header_param(msg, header, param)
 129
 130
 131 def _remove_headers_params(msg, header, remove_all_params, param_list):
 132     if remove_all_params:
 133         params = msg.get_params(header=header)
 134         if params:
 135             if param_list:
 136                 for param, value in params:
 137                     if param not in param_list:
 138                         msg.del_param(param, header)
 139             else:
 140                 value = msg[header]
 141                 if value is None:  # No such header
 142                     return
 143                 if ';' not in value:  # There are no parameters
 144                     return
 145                 del msg[header]  # Delete all such headers
 146                 # Get the value without parameters and set it back
 147                 msg[header] = value.split(';')[0].strip()
 148     else:
 149         for param in param_list:
 150             msg.del_param(param, header)
 151
 152
 153 def decode_headers(msg):
 154     "Decode message headers according to global options"
 155
 156     for header_list in g.remove_headers:
 157         header_list = header_list.split(',')
 158         if header_list[0] == '*':  # Remove all headers except listed
 159             header_list = _get_exceptions(header_list)
 160             for header in msg.keys():
 161                 if header.lower() not in header_list:
 162                     del msg[header]
 163         else:  # Remove listed headers
 164             for header in header_list:
 165                 del msg[header]
 166
 167     for header_list, param_list in g.remove_headers_params:
 168         header_list = header_list.split(',')
 169         param_list = param_list.split(',')
 170         # Remove all params except listed.
 171         remove_all_params = param_list[0] == '*'
 172         if remove_all_params:
 173             param_list = _get_exceptions(param_list)
 174         if header_list[0] == '*':  # Remove for all headers except listed
 175             header_list = _get_exceptions(header_list)
 176             for header in msg.keys():
 177                 if header.lower() not in header_list:
 178                     _remove_headers_params(
 179                         msg, header, remove_all_params, param_list)
 180         else:  # Decode for listed headers
 181             for header in header_list:
 182                 _remove_headers_params(
 183                     msg, header, remove_all_params, param_list)
 184
 185     for header_list in g.decode_headers:
 186         header_list = header_list.split(',')
 187         if header_list[0] == '*':  # Decode all headers except listed
 188             header_list = _get_exceptions(header_list)
 189             for header in msg.keys():
 190                 if header.lower() not in header_list:
 191                     decode_header(msg, header)
 192         else:  # Decode listed headers
 193             for header in header_list:
 194                 decode_header(msg, header)
 195
 196     for header_list, param_list in g.decode_header_params:
 197         header_list = header_list.split(',')
 198         param_list = param_list.split(',')
 199         # Decode all params except listed.
 200         decode_all_params = param_list[0] == '*'
 201         if decode_all_params:
 202             param_list = _get_exceptions(param_list)
 203         if header_list[0] == '*':  # Decode for all headers except listed
 204             header_list = _get_exceptions(header_list)
 205             for header in msg.keys():
 206                 if header.lower() not in header_list:
 207                     _decode_headers_params(
 208                         msg, header, decode_all_params, param_list)
 209         else:  # Decode for listed headers
 210             for header in header_list:
 211                 _decode_headers_params(
 212                     msg, header, decode_all_params, param_list)
 213
 214
 215 def set_header(msg, header, value):
 216     "Replace header"
 217
 218     if header in msg:
 219         msg.replace_header(header, value)
 220     else:
 221         msg[header] = value
 222
 223
 224 def set_content_type(msg, newtype, charset=None):
 225     msg.set_type(newtype)
 226
 227     if charset:
 228         msg.set_param("charset", charset, "Content-Type")
 229
 230
 231 caps = None  # Globally stored mailcap database; initialized only if needed
 232
 233
 234 def decode_body(msg, s):
 235     "Decode body to plain text using first copiousoutput filter from mailcap"
 236
 237     import mailcap
 238     import tempfile
 239
 240     global caps
 241     if caps is None:
 242         caps = mailcap.getcaps()
 243
 244     content_type = msg.get_content_type()
 245     if content_type.startswith('text/'):
 246         charset = msg.get_content_charset()
 247     else:
 248         charset = None
 249     filename = tempfile.mktemp()
 250     command = None
 251
 252     entries = mailcap.lookup(caps, content_type, "view")
 253     for entry in entries:
 254         if 'copiousoutput' in entry:
 255             if 'test' in entry:
 256                 test = mailcap.subst(entry['test'], content_type, filename)
 257                 if test and os.system(test) != 0:
 258                     continue
 259             command = mailcap.subst(entry["view"], content_type, filename)
 260             break
 261
 262     if not command:
 263         return s
 264
 265     outfile = open(filename, 'wb')
 266     if charset and bytes is not str and isinstance(s, bytes):  # Python3
 267         s = s.decode(charset, "replace")
 268     if not isinstance(s, bytes):
 269         s = s.encode(g.default_encoding, "replace")
 270     outfile.write(s)
 271     outfile.close()
 272
 273     pipe = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE)
 274     new_s = pipe.stdout.read()
 275     pipe.stdout.close()
 276     if pipe.wait() == 0:  # result=0, Ok
 277         s = new_s
 278         if bytes is not str and isinstance(s, bytes):  # Python3
 279             s = s.decode(g.default_encoding, "replace")
 280         if charset and not isinstance(s, bytes):
 281             s = s.encode(charset, "replace")
 282         set_content_type(msg, "text/plain")
 283         msg["X-MIME-Autoconverted"] = \
 284             "from %s to text/plain by %s id %s" \
 285             % (content_type, g.host_name, command.split()[0])
 286     else:
 287         msg["X-MIME-Autoconverted"] = \
 288             "failed conversion from %s to text/plain by %s id %s" \
 289             % (content_type, g.host_name, command.split()[0])
 290     os.remove(filename)
 291
 292     return s
 293
 294
 295 def recode_charset(msg, s):
 296     "Recode charset of the message to the default charset"
 297
 298     save_charset = charset = msg.get_content_charset()
 299     if charset and charset.lower() != g.default_encoding:
 300         s = recode_if_needed(s, charset)
 301         content_type = msg.get_content_type()
 302         set_content_type(msg, content_type, g.default_encoding)
 303         msg["X-MIME-Autoconverted"] = \
 304             "from %s to %s by %s id %s" \
 305             % (save_charset, g.default_encoding, g.host_name, me)
 306     return s
 307
 308
 309 def totext(msg, instring):
 310     "Convert instring content to text"
 311
 312     # Decode body and recode charset
 313     s = decode_body(msg, instring)
 314     if g.recode_charset:
 315         s = recode_charset(msg, s)
 316
 317     output_headers(msg)
 318     output(s)
 319     return s
 320
 321
 322 mimetypes = None
 323
 324
 325 def _guess_extension(ctype):
 326     global mimetypes
 327     if mimetypes is None:
 328         import mimetypes
 329         mimetypes.init()
 330         user_mime_type = os.path.expanduser('~/.mime.types')
 331         if os.path.exists(user_mime_type):
 332             mimetypes._db.read(user_mime_type)
 333     return mimetypes.guess_extension(ctype)
 334
 335
 336 def _save_message(msg, outstring, save_headers=False, save_body=False):
 337     for header, param in (
 338         ("Content-Disposition", "filename"),
 339         ("Content-Type", "name"),
 340     ):
 341         fname = msg.get_param(param, header=header)
 342         if fname:
 343             if isinstance(fname, tuple):
 344                 fname = fname[2]  # Do not recode if it isn't recoded yet
 345             try:
 346                     for forbidden in chr(0), '/', '\\':
 347                         if forbidden in fname:
 348                             raise ValueError
 349             except ValueError:
 350                 continue
 351             fname = '-' + fname
 352             break
 353     else:
 354         fname = ''
 355     g.save_counter += 1
 356     fname = str(g.save_counter) + fname
 357     if '.' not in fname:
 358         ext = _guess_extension(msg.get_content_type())
 359         if ext:
 360             fname += ext
 361
 362     global output
 363     save_output = output
 364     outfile = open_output_file(fname)
 365
 366     def _output_bytes(s):
 367         if not isinstance(s, bytes):
 368             s = s.encode(g.default_encoding, "replace")
 369         outfile.write(s)
 370
 371     output = _output_bytes
 372     if save_headers:
 373         output_headers(msg)
 374     if save_body:
 375         output(outstring)
 376     outfile.close()
 377     output = save_output
 378
 379
 380 def decode_part(msg):
 381     "Decode one part of the message"
 382
 383     decode_headers(msg)
 384
 385     # Test all mask lists and find what to do with this content type
 386     masks = []
 387     ctype = msg.get_content_type()
 388     if ctype:
 389         masks.append(ctype)
 390         mtype = ctype.split('/')[0]
 391         masks.append(mtype + '/*')
 392     masks.append('*/*')
 393
 394     left_binary = False
 395     for content_type in masks:
 396         if content_type in g.totext_mask or \
 397            content_type in g.decoded_binary_mask:
 398             break
 399         elif content_type in g.binary_mask:
 400             left_binary = True
 401             break
 402         elif content_type in g.fully_ignore_mask:
 403             return
 404
 405     encoding = msg["Content-Transfer-Encoding"]
 406     if left_binary or encoding in (None, '', '7bit', '8bit', 'binary'):
 407         outstring = msg.get_payload()
 408     else:  # Decode from transfer ecoding to text or binary form
 409         outstring = msg.get_payload(decode=1)
 410         set_header(msg, "Content-Transfer-Encoding", "8bit")
 411         msg["X-MIME-Autoconverted"] = \
 412             "from %s to 8bit by %s id %s" % (encoding, g.host_name, me)
 413
 414     for content_type in masks:
 415         if content_type in g.totext_mask:
 416             outstring = totext(msg, outstring)
 417             break
 418         elif content_type in g.binary_mask or \
 419                 content_type in g.decoded_binary_mask:
 420             output_headers(msg)
 421             output(outstring)
 422             break
 423         elif content_type in g.ignore_mask:
 424             output_headers(msg)
 425             output("%sMessage body of type %s skipped.%s"
 426                    % (os.linesep, ctype, os.linesep))
 427             break
 428         elif content_type in g.error_mask:
 429             break
 430     else:
 431         # Neither content type nor masks were listed - decode by default
 432         outstring = totext(msg, outstring)
 433
 434     for content_type in masks:
 435         if content_type in g.save_headers_mask:
 436             _save_message(msg, outstring, save_headers=True, save_body=False)
 437         if content_type in g.save_body_mask:
 438             _save_message(msg, outstring, save_headers=False, save_body=True)
 439         if content_type in g.save_message_mask:
 440             _save_message(msg, outstring, save_headers=True, save_body=True)
 441
 442     for content_type in masks:
 443         if content_type in g.error_mask:
 444             raise ValueError("content type %s prohibited" % ctype)
 445
 446
 447 def decode_multipart(msg):
 448     "Decode multipart"
 449
 450     decode_headers(msg)
 451     boundary = msg.get_boundary()
 452
 453     masks = []
 454     ctype = msg.get_content_type()
 455     if ctype:
 456         masks.append(ctype)
 457         mtype = ctype.split('/')[0]
 458         masks.append(mtype + '/*')
 459     masks.append('*/*')
 460
 461     for content_type in masks:
 462         if content_type in g.fully_ignore_mask:
 463             return
 464         elif content_type in g.ignore_mask:
 465             output_headers(msg)
 466             output("%sMessage body of type %s skipped.%s"
 467                    % (os.linesep, ctype, os.linesep))
 468             if boundary:
 469                 output("%s--%s--%s" % (os.linesep, boundary, os.linesep))
 470             return
 471
 472     for content_type in masks:
 473         if content_type in g.save_body_mask or \
 474                 content_type in g.save_message_mask:
 475             _out_l = []
 476             first_subpart = True
 477             for subpart in msg.get_payload():
 478                 if first_subpart:
 479                     first_subpart = False
 480                 else:
 481                     _out_l.append(os.linesep)
 482                 _out_l.append("--%s%s" % (boundary, os.linesep))
 483                 _out_l.append(subpart.as_string())
 484             _out_l.append("%s--%s--%s" % (os.linesep, boundary, os.linesep))
 485             outstring = ''.join(_out_l)
 486             break
 487     else:
 488         outstring = None
 489
 490     for content_type in masks:
 491         if content_type in g.save_headers_mask:
 492             _save_message(msg, outstring, save_headers=True, save_body=False)
 493         if content_type in g.save_body_mask:
 494             _save_message(msg, outstring, save_headers=False, save_body=True)
 495         if content_type in g.save_message_mask:
 496             _save_message(msg, outstring, save_headers=True, save_body=True)
 497
 498     for content_type in masks:
 499         if content_type in g.error_mask:
 500             raise ValueError("content type %s prohibited" % ctype)
 501
 502     output_headers(msg)
 503
 504     # Preserve the first part, it is probably not a RFC822-message.
 505     if msg.preamble:
 506         # Usually it is just a few lines of text (MIME warning).
 507         output(msg.preamble)
 508     if msg.preamble is not None:
 509         output(os.linesep)
 510
 511     first_subpart = True
 512     for subpart in msg.get_payload():
 513         if boundary:
 514             if first_subpart:
 515                 first_subpart = False
 516             else:
 517                 output(os.linesep)
 518             output("--%s%s" % (boundary, os.linesep))
 519
 520         # Recursively decode all parts of the subpart
 521         decode_message(subpart)
 522
 523     if boundary:
 524         output("%s--%s--%s" % (os.linesep, boundary, os.linesep))
 525
 526     if msg.epilogue:
 527         output(msg.epilogue)
 528
 529
 530 def decode_message(msg):
 531     "Decode message"
 532
 533     if msg.is_multipart():
 534         decode_multipart(msg)
 535     elif len(msg):  # Simple one-part message (there are headers) - decode it
 536         decode_part(msg)
 537     else:  # Not a message, just text - copy it literally
 538         output(msg.as_string())
 539
 540
 541 def open_output_file(filename):
 542     fullpath = os.path.abspath(os.path.join(g.destination_dir, filename))
 543     full_dir = os.path.dirname(fullpath)
 544     create = not os.path.isdir(full_dir)
 545     if create:
 546         os.makedirs(full_dir)
 547     try:
 548         return open(fullpath, 'wb')
 549     except Exception:
 550         if create:
 551             os.removedirs(full_dir)
 552
 553
 554 class GlobalOptions:
 555     from m_lib.defenc import default_encoding
 556     recode_charset = 1  # recode charset of message body
 557
 558     host_name = None
 559
 560     # A list of headers to decode
 561     decode_headers = ["From", "To", "Cc", "Reply-To", "Mail-Followup-To",
 562                       "Subject"]
 563
 564     # A list of headers parameters to decode
 565     decode_header_params = [
 566         ("Content-Type", "name"),
 567         ("Content-Disposition", "filename"),
 568     ]
 569
 570     # A list of headers to remove
 571     remove_headers = []
 572     # A list of headers parameters to remove
 573     remove_headers_params = []
 574
 575     # A list of header/value pairs to set
 576     set_header_value = []
 577     # A list of header/parameter/value triples to set
 578     set_header_param = []
 579
 580     totext_mask = []  # A list of content-types to decode
 581     binary_mask = []  # A list of content-types to pass through
 582     # A list of content-types to pass through (content-transfer-decoded).
 583     decoded_binary_mask = []
 584     # Ignore (do not decode and do not include into output)
 585     # but output a warning instead of the body.
 586     ignore_mask = []
 587     # Completely ignore - no headers, no body, no warning.
 588     fully_ignore_mask = []
 589     error_mask = []  # Raise error if encounter one of these
 590
 591     save_counter = 0
 592     save_headers_mask = []
 593     save_body_mask = []
 594     save_message_mask = []
 595
 596     input_filename = None
 597     output_filename = None
 598     destination_dir = os.curdir
 599
 600
 601 g = GlobalOptions
 602
 603
 604 def get_opts():
 605     from getopt import getopt, GetoptError
 606
 607     try:
 608         options, arguments = getopt(
 609             sys.argv[1:],
 610             'hVcCDPH:f:d:p:r:R:b:B:e:I:i:t:O:o:',
 611             ['help', 'version', 'host=',
 612              'save-headers=', 'save-body=', 'save-message=',
 613              'set-header=', 'set-param='])
 614     except GetoptError:
 615         usage(1)
 616
 617     for option, value in options:
 618         if option in ('-h', '--help'):
 619             usage()
 620         elif option in ('-V', '--version'):
 621             version()
 622         elif option == '-c':
 623             g.recode_charset = 1
 624         elif option == '-C':
 625             g.recode_charset = 0
 626         elif option in ('-H', '--host'):
 627             g.host_name = value
 628         elif option == '-f':
 629             g.default_encoding = value
 630         elif option == '-d':
 631             if value.startswith('*'):
 632                 g.decode_headers = []
 633             g.decode_headers.append(value)
 634         elif option == '-D':
 635             g.decode_headers = []
 636         elif option == '-p':
 637             g.decode_header_params.append(value.split(':', 1))
 638         elif option == '-P':
 639             g.decode_header_params = []
 640         elif option == '-r':
 641             g.remove_headers.append(value)
 642         elif option == '-R':
 643             g.remove_headers_params.append(value.split(':', 1))
 644         elif option == '--set-header':
 645             g.set_header_value.append(value.split(':', 1))
 646         elif option == '--set-param':
 647             header, value = value.split(':', 1)
 648             if '=' in value:
 649                 param, value = value.split('=', 1)
 650             else:
 651                 param, value = value.split(':', 1)
 652             g.set_header_param.append((header, param, value))
 653         elif option == '-t':
 654             g.totext_mask.append(value)
 655         elif option == '-B':
 656             g.binary_mask.append(value)
 657         elif option == '-b':
 658             g.decoded_binary_mask.append(value)
 659         elif option == '-I':
 660             g.fully_ignore_mask.append(value)
 661         elif option == '-i':
 662             g.ignore_mask.append(value)
 663         elif option == '-e':
 664             g.error_mask.append(value)
 665         elif option == '--save-headers':
 666             g.save_headers_mask.append(value)
 667         elif option == '--save-body':
 668             g.save_body_mask.append(value)
 669         elif option == '--save-message':
 670             g.save_message_mask.append(value)
 671         elif option == '-O':
 672             g.destination_dir = value
 673         elif option == '-o':
 674             g.output_filename = value
 675         else:
 676             usage(1)
 677
 678     return arguments
 679
 680
 681 if __name__ == "__main__":
 682     arguments = get_opts()
 683
 684     la = len(arguments)
 685     if la == 0:
 686         g.input_filename = '-'
 687         infile = sys.stdin
 688         if g.output_filename:
 689             outfile = open_output_file(g.output_filename)
 690         else:
 691             g.output_filename = '-'
 692             outfile = sys.stdout
 693     elif la in (1, 2):
 694         if (arguments[0] == '-'):
 695             g.input_filename = '-'
 696             infile = sys.stdin
 697         else:
 698             g.input_filename = arguments[0]
 699             infile = open(arguments[0], 'r')
 700         if la == 1:
 701             if g.output_filename:
 702                 outfile = open_output_file(g.output_filename)
 703             else:
 704                 g.output_filename = '-'
 705                 outfile = sys.stdout
 706         elif la == 2:
 707             if g.output_filename:
 708                 usage(1, 'Too many output filenames')
 709             if (arguments[1] == '-'):
 710                 g.output_filename = '-'
 711                 outfile = sys.stdout
 712             else:
 713                 g.output_filename = arguments[1]
 714                 outfile = open_output_file(g.output_filename)
 715     else:
 716         usage(1, 'Too many arguments')
 717
 718     if (infile is sys.stdin) and sys.stdin.isatty():
 719         if (outfile is sys.stdout) and sys.stdout.isatty():
 720             usage()
 721         usage(1, 'Filtering from console is forbidden')
 722
 723     if not g.host_name:
 724         import socket
 725         g.host_name = socket.gethostname()
 726
 727     g.outfile = outfile
 728     if hasattr(outfile, 'buffer'):
 729         def output_bytes(s):
 730             if not isinstance(s, bytes):
 731                 s = s.encode(g.default_encoding, "replace")
 732             outfile.buffer.write(s)
 733         output = output_bytes
 734     else:
 735         output = outfile.write
 736
 737     import email
 738     msg = email.message_from_file(infile)
 739
 740     for header, value in g.set_header_value:
 741         set_header(msg, header, value)
 742
 743     for header, param, value in g.set_header_param:
 744         if header in msg:
 745             msg.set_param(param, value, header)
 746
 747     try:
 748         decode_message(msg)
 749     finally:
 750         infile.close()
 751         outfile.close()