X-Git-Url: https://git.phdru.name/?a=blobdiff_plain;f=mimedecode.py;h=c1731d6336c5ab8eff9e5928a61a9cce1181ddc2;hb=41e92ab685cbcf842d1c4f33b8b29f94193938ed;hp=5d84a27621954b82724b385282e5bb1f9b358cf6;hpb=68e059f66ec0d4db1ad741bc21e6b10c5db51436;p=mimedecode.git

diff --git a/mimedecode.py b/mimedecode.py
index 5d84a27..c1731d6 100755
--- a/mimedecode.py
+++ b/mimedecode.py
@@ -1,22 +1,11 @@
 #! /usr/bin/env python
 """Decode MIME message"""
 
-
 from mimedecode_version import __version__, __author__, __copyright__, __license__
 
-
 import sys, os
 import email
 
-try:
-    from cStringIO import StringIO
-except ImportError:
-    from StringIO import StringIO
-
-
-import socket
-host_name = socket.gethostname()
-
 me = os.path.basename(sys.argv[0])
 
 
@@ -26,34 +15,28 @@ Broytman mimedecode.py version %s, %s
 """ % (__version__, __copyright__))
     if exit: sys.exit(0)
 
-
-def usage(code=0):
+def usage(code=0, errormsg=''):
     version(0)
     sys.stdout.write("""\
-Usage: %s [-h|--help] [-V|--version] [-cCDP] [-f charset] [-d header] [-p header:param] [-beit mask] [filename]
+        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]]
 """ % me)
+    if errormsg:
+        sys.stderr.write(errormsg + '\n')
     sys.exit(code)
 
 
-def output(s, outfile=sys.stdout):
-    outfile.write(s)
-
-def output_headers(msg, outfile=sys.stdout):
+def output_headers(msg):
     unix_from = msg.get_unixfrom()
     if unix_from:
-        output(unix_from + os.linesep)
+        output(unix_from + '\n')
     for key, value in msg.items():
-        output("%s: %s\n" % (key, value), outfile)
-    output("\n", outfile) # End of headers
-
-
-def recode(s, charset):
-    return unicode(s, charset, "replace").encode(GlobalOptions.default_encoding, "replace")
+        output("%s: %s\n" % (key, value))
+    output("\n") # End of headers
 
 
-def recode2(s, charset):
-    if charset and charset.lower() <> GlobalOptions.default_encoding:
-        s = recode(s, charset)
+def recode_if_needed(s, charset):
+    if charset and charset.lower() <> g.default_encoding:
+        s = unicode(s, charset, "replace").encode(g.default_encoding, "replace")
     return s
 
 
@@ -61,11 +44,10 @@ def _decode_header(s):
     """Return a decoded string according to RFC 2047.
     NOTE: This is almost the same as email.Utils.decode.
     """
-    from types import ListType
     import email.Header
 
     L = email.Header.decode_header(s)
-    if not isinstance(L, ListType):
+    if not isinstance(L, list):
         # s wasn't decoded
         return s
 
@@ -74,7 +56,7 @@ def _decode_header(s):
         if charset is None:
             rtn.append(atom)
         else:
-            rtn.append(recode2(atom, charset))
+            rtn.append(recode_if_needed(atom, charset))
         rtn.append(' ')
     del rtn[-1] # remove the last space
 
@@ -82,7 +64,6 @@ def _decode_header(s):
     # together into the final string.
     return ''.join(rtn)
 
-
 def decode_header(msg, header):
     "Decode mail header (if exists) and put it back, if it was encoded"
 
@@ -93,33 +74,109 @@ def decode_header(msg, header):
             set_header(msg, header, new_value)
 
 
-def _decode_header_param(s):
-    return recode2(s[2], s[0])
-
-
 def decode_header_param(msg, header, param):
     "Decode mail header's parameter (if exists) and put it back, if it was encoded"
 
     if msg.has_key(header):
         value = msg.get_param(param, header=header)
         if value:
-            from types import TupleType
-            if isinstance(value, TupleType):
-                new_value = _decode_header_param(value)
+            if isinstance(value, tuple):
+                new_value = recode_if_needed(value[2], value[0])
             else:
                 new_value = _decode_header(value)
             if new_value <> value: # do not bother to touch msg if not changed
                 msg.set_param(param, new_value, header)
 
 
+def _get_exceptions(list):
+    return [x[1:].lower() for x in list[1:] if x[0]=='-']
+
+def _decode_headers_params(msg, header, decode_all_params, param_list):
+    if decode_all_params:
+        params = msg.get_params(header=header)
+        if params:
+            for param, value in params:
+                if param not in param_list:
+                    decode_header_param(msg, header, param)
+    else:
+        for param in param_list:
+            decode_header_param(msg, header, param)
+
+def _remove_headers_params(msg, header, remove_all_params, param_list):
+    if remove_all_params:
+        params = msg.get_params(header=header)
+        if params:
+            if param_list:
+                for param, value in params:
+                    if param not in param_list:
+                        msg.del_param(param, header)
+            else:
+                value = msg[header]
+                if value is None: # No such header
+                    return
+                if ';' not in value: # There are no parameters
+                    return
+                del msg[header] # Delete all such headers
+                # Get the value without parameters and set it back
+                msg[header] = value.split(';')[0].strip()
+    else:
+        for param in param_list:
+            msg.del_param(param, header)
+
 def decode_headers(msg):
     "Decode message headers according to global options"
 
-    for header in GlobalOptions.decode_headers:
-        decode_header(msg, header)
-
-    for header, param in GlobalOptions.decode_header_params:
-        decode_header_param(msg, header, param)
+    for header_list in g.remove_headers:
+        header_list = header_list.split(',')
+        if header_list[0] == '*': # Remove all headers except listed
+            header_list = _get_exceptions(header_list)
+            for header in msg.keys():
+                if header.lower() not in header_list:
+                    del msg[header]
+        else: # Remove listed headers
+            for header in header_list:
+                del msg[header]
+
+    for header_list, param_list in g.remove_headers_params:
+        header_list = header_list.split(',')
+        param_list = param_list.split(',')
+        remove_all_params = param_list[0] == '*' # Remove all params except listed
+        if remove_all_params:
+            param_list = _get_exceptions(param_list)
+        if header_list[0] == '*': # Remove for all headers except listed
+            header_list = _get_exceptions(header_list)
+            for header in msg.keys():
+                if header.lower() not in header_list:
+                    _remove_headers_params(msg, header, remove_all_params, param_list)
+        else: # Decode for listed headers
+            for header in header_list:
+                _remove_headers_params(msg, header, remove_all_params, param_list)
+
+    for header_list in g.decode_headers:
+        header_list = header_list.split(',')
+        if header_list[0] == '*': # Decode all headers except listed
+            header_list = _get_exceptions(header_list)
+            for header in msg.keys():
+                if header.lower() not in header_list:
+                    decode_header(msg, header)
+        else: # Decode listed headers
+            for header in header_list:
+                decode_header(msg, header)
+
+    for header_list, param_list in g.decode_header_params:
+        header_list = header_list.split(',')
+        param_list = param_list.split(',')
+        decode_all_params = param_list[0] == '*' # Decode all params except listed
+        if decode_all_params:
+            param_list = _get_exceptions(param_list)
+        if header_list[0] == '*': # Decode for all headers except listed
+            header_list = _get_exceptions(header_list)
+            for header in msg.keys():
+                if header.lower() not in header_list:
+                    _decode_headers_params(msg, header, decode_all_params, param_list)
+        else: # Decode for listed headers
+            for header in header_list:
+                _decode_headers_params(msg, header, decode_all_params, param_list)
 
 
 def set_header(msg, header, value):
@@ -138,7 +195,6 @@ def set_content_type(msg, newtype, charset=None):
         msg.set_param("charset", charset, "Content-Type")
 
 
-
 caps = None # Globally stored mailcap database; initialized only if needed
 
 def decode_body(msg, s):
@@ -177,7 +233,7 @@ def decode_body(msg, s):
     os.remove(filename)
 
     set_content_type(msg, "text/plain")
-    msg["X-MIME-Autoconverted"] = "from %s to text/plain by %s id %s" % (content_type, host_name, command.split()[0])
+    msg["X-MIME-Autoconverted"] = "from %s to text/plain by %s id %s" % (content_type, g.host_name, command.split()[0])
 
     return s
 
@@ -186,44 +242,57 @@ def recode_charset(msg, s):
     "Recode charset of the message to the default charset"
 
     save_charset = charset = msg.get_content_charset()
-    if charset and charset.lower() <> GlobalOptions.default_encoding:
-        s = recode2(s, charset)
+    if charset and charset.lower() <> g.default_encoding:
+        s = recode_if_needed(s, charset)
         content_type = msg.get_content_type()
-        set_content_type(msg, content_type, GlobalOptions.default_encoding)
-        msg["X-MIME-Autoconverted"] = "from %s to %s by %s id %s" % (save_charset, GlobalOptions.default_encoding, host_name, me)
+        set_content_type(msg, content_type, g.default_encoding)
+        msg["X-MIME-Autoconverted"] = "from %s to %s by %s id %s" % (save_charset, g.default_encoding, g.host_name, me)
     return s
 
 
 def totext(msg, instring):
     "Convert instring content to text"
 
-    if msg.is_multipart(): # Recursively decode all parts of the multipart message
-        newfile = StringIO(str(msg))
-        newfile.seek(0)
-        decode_file(newfile)
-        return
-
     # Decode body and recode charset
     s = decode_body(msg, instring)
-    if GlobalOptions.recode_charset:
+    if g.recode_charset:
         s = recode_charset(msg, s)
 
     output_headers(msg)
     output(s)
+    return s
+
+
+def _save_message(msg, outstring, save_headers=False, save_body=False):
+    for header, param in (
+        ("Content-Disposition", "filename"),
+        ("Content-Type", "name"),
+    ):
+        fname = msg.get_param(param, header=header)
+        if fname:
+            fname = '-' + fname
+            break
+    else:
+        fname = ''
+    g.save_counter += 1
+    fname = str(g.save_counter) + fname
+
+    global output
+    save_output = output
+    outfile = open_output_file(fname)
+    output = outfile.write
+    if save_headers:
+        output_headers(msg)
+    if save_body:
+        output(outstring)
+    outfile.close()
+    output = save_output
 
 
 def decode_part(msg):
     "Decode one part of the message"
 
     decode_headers(msg)
-    encoding = msg["Content-Transfer-Encoding"]
-
-    if encoding in (None, '', '7bit', '8bit', 'binary'):
-        outstring = str(msg.get_payload())
-    else: # Decode from transfer ecoding to text or binary form
-        outstring = str(msg.get_payload(decode=1))
-        set_header(msg, "Content-Transfer-Encoding", "8bit")
-        msg["X-MIME-Autoconverted"] = "from %s to 8bit by %s id %s" % (encoding, host_name, me)
 
     # Test all mask lists and find what to do with this content type
     masks = []
@@ -235,111 +304,222 @@ def decode_part(msg):
         masks.append(mtype + '/*')
     masks.append('*/*')
 
+    left_binary = False
     for content_type in masks:
-        if content_type in GlobalOptions.totext_mask:
-            totext(msg, outstring)
-            return
-        elif content_type in GlobalOptions.binary_mask:
+        if content_type in g.totext_mask or \
+           content_type in g.decoded_binary_mask:
+            break
+        elif content_type in g.binary_mask:
+            left_binary = True
+            break
+
+    encoding = msg["Content-Transfer-Encoding"]
+    if left_binary or encoding in (None, '', '7bit', '8bit', 'binary'):
+        outstring = msg.get_payload()
+    else: # Decode from transfer ecoding to text or binary form
+        outstring = msg.get_payload(decode=1)
+        set_header(msg, "Content-Transfer-Encoding", "8bit")
+        msg["X-MIME-Autoconverted"] = "from %s to 8bit by %s id %s" % (encoding, g.host_name, me)
+
+    for content_type in masks:
+        if content_type in g.totext_mask:
+            outstring = totext(msg, outstring)
+            break
+        elif content_type in g.binary_mask or \
+             content_type in g.decoded_binary_mask:
             output_headers(msg)
             output(outstring)
-            return
-        elif content_type in GlobalOptions.ignore_mask:
+            break
+        elif content_type in g.ignore_mask:
             output_headers(msg)
-            output("\nMessage body of type `%s' skipped.\n" % content_type)
-            return
-        elif content_type in GlobalOptions.error_mask:
-            raise ValueError, "content type `%s' prohibited" % content_type
+            output("\nMessage body of type %s skipped.\n" % ctype)
+            break
+        elif content_type in g.error_mask:
+            break
+    else:
+        # Neither content type nor masks were listed - decode by default
+        outstring = totext(msg, outstring)
 
-    # Neither content type nor masks were listed - decode by default
-    totext(msg, outstring)
+    for content_type in masks:
+        if content_type in g.save_headers_mask:
+            _save_message(msg, outstring, save_headers=True, save_body=False)
+        elif content_type in g.save_body_mask:
+            _save_message(msg, outstring, save_headers=False, save_body=True)
+        elif content_type in g.save_message_mask:
+            _save_message(msg, outstring, save_headers=True, save_body=True)
 
+    for content_type in masks:
+        if content_type in g.error_mask:
+            raise ValueError, "content type %s prohibited" % ctype
 
-def decode_file(infile):
-    "Decode the entire message"
+def decode_multipart(msg):
+    "Decode multipart"
 
-    msg = email.message_from_file(infile)
-    boundary = msg.get_boundary()
+    decode_headers(msg)
+    output_headers(msg)
 
-    if msg.is_multipart():
-        decode_headers(msg)
-        output_headers(msg)
+    if msg.preamble: # Preserve the first part, it is probably not a RFC822-message
+        output(msg.preamble) # Usually it is just a few lines of text (MIME warning)
+    if msg.preamble is not None:
+        output("\n")
 
-        if msg.preamble: # Preserve the first part, it is probably not a RFC822-message
-            output(msg.preamble) # Usually it is just a few lines of text (MIME warning)
+    first_subpart = True
+    boundary = msg.get_boundary()
+
+    for subpart in msg.get_payload():
+        if boundary:
+            if first_subpart:
+                first_subpart = False
+            else:
+                output("\n")
+            output("--%s\n" % boundary)
 
-        for subpart in msg.get_payload():
-            output("\n--%s\n" % boundary)
-            decode_part(subpart)
+        # Recursively decode all parts of the subpart
+        decode_message(subpart)
 
+    if boundary:
         output("\n--%s--\n" % boundary)
 
-        if msg.epilogue:
-            output(msg.epilogue)
+    if msg.epilogue:
+        output(msg.epilogue)
 
-    else:
-        if msg.has_key("Content-Type"): # Simple one-part message - decode it
-            decode_part(msg)
 
-        else: # Not a message, just text - copy it literally
-            output(str(msg))
+def decode_message(msg):
+    "Decode message"
+
+    if msg.is_multipart():
+        decode_multipart(msg)
+    elif len(msg): # Simple one-part message (there are headers) - decode it
+        decode_part(msg)
+    else: # Not a message, just text - copy it literally
+        output(msg.as_string())
+
+
+def open_output_file(filename):
+    fullpath = os.path.abspath(os.path.join(g.destination_dir, filename))
+    full_dir = os.path.dirname(fullpath)
+    create = not os.path.isdir(full_dir)
+    if create:
+        os.makedirs(full_dir)
+    try:
+        return open(fullpath, 'w')
+    except:
+        if create:
+            os.removedirs(full_dir)
 
 
 class GlobalOptions:
     from m_lib.defenc import default_encoding
     recode_charset = 1 # recode charset of message body
 
-    decode_headers = ["From", "Subject"] # A list of headers to decode
+    host_name = None
+
+    # A list of headers to decode
+    decode_headers = ["From", "To", "Cc", "Reply-To", "Mail-Followup-To",
+                      "Subject"]
+
+    # A list of headers parameters to decode
     decode_header_params = [
         ("Content-Type", "name"),
         ("Content-Disposition", "filename"),
-    ] # A list of headers' parameters to decode
+    ]
+
+    # A list of headers to remove
+    remove_headers = []
+    # A list of headers parameters to remove
+    remove_headers_params = []
+
+    # A list of header/value pairs to set
+    set_header_value = []
+    # A list of header/parameter/value triples to set
+    set_header_param = []
 
     totext_mask = [] # A list of content-types to decode
-    binary_mask = [] # A list to pass through
+    binary_mask = [] # A list of content-types to pass through
+    decoded_binary_mask = [] # A list of content-types to pass through (content-transfer-decoded)
     ignore_mask = [] # Ignore (skip, do not decode and do not include into output)
     error_mask = []  # Raise error if encounter one of these
 
+    save_counter = 0
+    save_headers_mask = []
+    save_body_mask = []
+    save_message_mask = []
+
+    input_filename = None
+    output_filename = None
+    destination_dir = os.curdir
+
+g = GlobalOptions
 
-def init():
+
+def get_opts():
     from getopt import getopt, GetoptError
 
     try:
-        options, arguments = getopt(sys.argv[1:], 'hVcCDPf:d:p:b:e:i:t:',
-            ['help', 'version'])
+        options, arguments = getopt(sys.argv[1:],
+            'hVcCDPH:f:d:p:r:R:b:B:e:i:t:O:o:',
+            ['help', 'version', 'host=',
+             'save-headers=', 'save-body=', 'save-message=',
+             'set-header=', 'set-param='])
     except GetoptError:
         usage(1)
 
     for option, value in options:
-        if option == '-h':
-            usage()
-        elif option == '--help':
+        if option in ('-h', '--help'):
             usage()
-        elif option == '-V':
-            version()
-        elif option == '--version':
+        elif option in ('-V', '--version'):
             version()
         elif option == '-c':
-            GlobalOptions.recode_charset = 1
+            g.recode_charset = 1
         elif option == '-C':
-            GlobalOptions.recode_charset = 0
+            g.recode_charset = 0
+        elif option in ('-H', '--host'):
+            g.host_name = value
         elif option == '-f':
-            GlobalOptions.default_encoding = value
+            g.default_encoding = value
         elif option == '-d':
-            GlobalOptions.decode_headers.append(value)
+            if value.startswith('*'):
+                g.decode_headers = []
+            g.decode_headers.append(value)
         elif option == '-D':
-            GlobalOptions.decode_headers = []
+            g.decode_headers = []
         elif option == '-p':
-            GlobalOptions.decode_header_params.append(value.split(':', 1))
+            g.decode_header_params.append(value.split(':', 1))
         elif option == '-P':
-            GlobalOptions.decode_header_params = []
+            g.decode_header_params = []
+        elif option == '-r':
+            g.remove_headers.append(value)
+        elif option == '-R':
+            g.remove_headers_params.append(value.split(':', 1))
+        elif option == '--set-header':
+            g.set_header_value.append(value.split(':', 1))
+        elif option == '--set-param':
+            header, value = value.split(':', 1)
+            if '=' in value:
+                param, value = value.split('=', 1)
+            else:
+                param, value = value.split(':', 1)
+            g.set_header_param.append((header, param, value))
         elif option == '-t':
-            GlobalOptions.totext_mask.append(value)
+            g.totext_mask.append(value)
+        elif option == '-B':
+            g.binary_mask.append(value)
         elif option == '-b':
-            GlobalOptions.binary_mask.append(value)
+            g.decoded_binary_mask.append(value)
         elif option == '-i':
-            GlobalOptions.ignore_mask.append(value)
+            g.ignore_mask.append(value)
         elif option == '-e':
-            GlobalOptions.error_mask.append(value)
+            g.error_mask.append(value)
+        elif option == '--save-headers':
+            g.save_headers_mask.append(value)
+        elif option == '--save-body':
+            g.save_body_mask.append(value)
+        elif option == '--save-message':
+            g.save_message_mask.append(value)
+        elif option == '-O':
+            g.destination_dir = value
+        elif option == '-o':
+            g.output_filename = value
         else:
             usage(1)
 
@@ -347,14 +527,65 @@ def init():
 
 
 if __name__ == "__main__":
-    arguments = init()
+    arguments = get_opts()
 
     la = len(arguments)
-    if la >= 2:
-        usage(1)
-    if (la == 0) or (arguments[0] == '-'):
+    if la == 0:
+        g.input_filename = '-'
         infile = sys.stdin
+        if g.output_filename:
+            outfile = open_output_file(g.output_filename)
+        else:
+            g.output_filename = '-'
+            outfile = sys.stdout
+    elif la in (1, 2):
+        if (arguments[0] == '-'):
+            g.input_filename = '-'
+            infile = sys.stdin
+        else:
+            g.input_filename = arguments[0]
+            infile = open(arguments[0], 'r')
+        if la == 1:
+            if g.output_filename:
+                outfile = open_output_file(g.output_filename)
+            else:
+                g.output_filename = '-'
+                outfile = sys.stdout
+        elif la == 2:
+            if g.output_filename:
+                usage(1, 'Too many output filenames')
+            if (arguments[1] == '-'):
+                g.output_filename = '-'
+                outfile = sys.stdout
+            else:
+                g.output_filename = arguments[1]
+                outfile = open_output_file(g.output_filename)
     else:
-        infile = open(arguments[0], 'r')
+        usage(1, 'Too many arguments')
+
+    if (infile is sys.stdin) and sys.stdin.isatty():
+        if (outfile is sys.stdout) and sys.stdout.isatty():
+            usage()
+        usage(1, 'Filtering from console is forbidden')
+
+    if not g.host_name:
+        import socket
+        g.host_name = socket.gethostname()
+
+    g.outfile = outfile
+    output = outfile.write
 
-    decode_file(infile)
+    msg = email.message_from_file(infile)
+
+    for header, value in g.set_header_value:
+        set_header(msg, header, value)
+
+    for header, param, value in g.set_header_param:
+        if header in msg:
+            msg.set_param(param, value, header)
+
+    try:
+        decode_message(msg)
+    finally:
+        infile.close()
+        outfile.close()