#!/usr/bin/env python

# -*- coding: utf-8 -*-

##############################################################################

# decodemif.py - Decodes a Symbian OS v9.x multi-image file (MIF)

# Copyright 2006, 2007 Jussi Ylänen

#

# This program is part of Ensymble developer utilities for Symbian OS(TM).

#

# Ensymble is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# Ensymble is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with Ensymble; if not, write to the Free Software

# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

#

#

# Version history

# ---------------

#

# v0.03 2006-09-22

# Replaced every possible range(...) with xrange(...) for efficiency

#

# v0.02 2006-08-22

# Added file type recognition (SVG, binary SVG or other)

#

# v0.01 2006-08-14

# Added support for strange index entries (length 0)

#

# v0.00 2006-08-13

# Work started

##############################################################################

VERSION = "v0.02 2006-09-22"

import sys

import os

import struct

import getopt

import random

import tempfile

# Parameters

MAXMIFFILESIZE      = 1024 * 1024       # Arbitrary maximum size of MIF file

tempdir = None

dumpcounter = 0

def mkdtemp(template):

    '''

    Create a unique temporary directory.

    tempfile.mkdtemp() was introduced in Python v2.3. This is for

    backward compatibility.

    '''

    # Cross-platform way to determine a suitable location for temporary files.

    systemp = tempfile.gettempdir()

    if not template.endswith("XXXXXX"):

        raise ValueError("invalid template for mkdtemp(): %s" % template)

    for n in xrange(10000):

        randchars = []

        for m in xrange(6):

            randchars.append(random.choice("abcdefghijklmnopqrstuvwxyz"))

        tempdir = os.path.join(systemp, template[: -6]) + "".join(randchars)

        try:

            os.mkdir(tempdir, 0700)

            return tempdir

        except OSError:

            pass

def dumpdata(data):

    '''Dumps data to a file in a temporary directory.'''

    global tempdir, dumpcounter

    if tempdir == None:

        # Create temporary directory for dumped files.

        tempdir = mkdtemp("decodemif-XXXXXX")

        dumpcounter = 0

    # Determine file type.

    if data[0:5] == "<?xml":

        ext = "svg"

    elif data[0:4] == '\xcc\x56\xfa\x03':

        ext = "svgb"

    else:

        ext = "dat"

    filename = os.path.join(tempdir, "dump%04d.%s" % (dumpcounter, ext))

    dumpcounter += 1

    f = file(filename, "wb")

    f.write(data)

    f.close()

    print "%s written" % filename

def main():

    global tempdir, dumpcounter

    pgmname     = os.path.basename(sys.argv[0])

    pgmversion  = VERSION

    try:

        try:

            gopt = getopt.gnu_getopt

        except:

            # Python <v2.3, GNU-style parameter ordering not supported.

            gopt = getopt.getopt

        # Parse command line using getopt.

        short_opts = "t:h"

        long_opts = [

            "dumpdir", "help"

        ]

        args = gopt(sys.argv[1:], short_opts, long_opts)

        opts = dict(args[0])

        pargs = args[1]

        if "--help" in opts.keys() or "-h" in opts.keys():

            # Help requested.

            print (

'''

DecodeMIF - Symbian OS v9.x MIF file decoder %(pgmversion)s

usage: %(pgmname)s [--dumpdir=DIR] [miffiles...]

        -t, --dumpdir       - Directory to use for dumped files (or automatic)

        miffiles            - MIF files to decode (stdin if not given or -)

''' % locals())

            return 0

        # A temporary directory is generated by default.

        tempdir = opts.get("--dumpdir", opts.get("-t", None))

        if len(pargs) == 0:

            miffilenames = ["-"]

        else:

            miffilenames = pargs

        for miffilename in miffilenames:

            if miffilename == '-':

                miffile = sys.stdin

            else:

                miffile = file(miffilename, "rb")

            try:

                # Load the whole MIF file as a string.

                mifdata = miffile.read(MAXMIFFILESIZE)

                if len(mifdata) == MAXMIFFILESIZE:

                    raise IOError("%s: file too large" % miffilename)

            finally:

                if miffile != sys.stdin:

                    miffile.close()

            # Verify MIF signature.

            if mifdata[:4] != "B##4":

                raise ValueError("%s: not a MIF file" % miffilename)

            if len(mifdata) < 16:

                raise ValueError("%s: file too short" % miffilename)

            entries = struct.unpack("<L", mifdata[12:16])[0] / 2

            # Verify header length:

            # 16-byte header, 16 bytes per index entry

            if len(mifdata) < (16 + 16 * entries):

                raise ValueError("%s: file too short" % miffilename)

            # Read index.

            index = []

            for n in xrange(entries):

                hdroff = 16 + n * 16

                a = struct.unpack("<L", mifdata[hdroff +  0:hdroff + 4])[0]

                b = struct.unpack("<L", mifdata[hdroff +  4:hdroff + 8])[0]

                c = struct.unpack("<L", mifdata[hdroff +  8:hdroff + 12])[0]

                d = struct.unpack("<L", mifdata[hdroff + 12:hdroff + 16])[0]

                if b == 0 and d == 0:

                    # Unknown index entry type, skip it.

                    continue

                if a != c or b != d:

                    raise ValueError("%s: invalid index entry %d" %

                                     (miffilename, n))

                # Check total length of file.

                if a + b > len(mifdata):

                    raise ValueError("%s: index %d out of range" %

                                     (miffilename, n))

                index.append((a, b))

            n = len(index)

            print "%s: %s %s inside" % (miffilename, n or "no",

                                        ((n == 1) and "file") or "files")

            # Extract contents.

            for i in index:

                offset = i[0]

                length = i[1]

                if mifdata[offset:offset + 4] != "C##4":

                    raise ValueError("%s: invalid file header %d" %

                                     (miffilename, n))

                print "0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x" % (

                    tuple(struct.unpack("<LLLLLLL", mifdata[(offset + 4):

                                                            (offset + 32)])))

                dumpdata(mifdata[offset + 32:offset + length + 32])

    except (TypeError, ValueError, IOError, OSError), e:

        return "%s: %s" % (pgmname, str(e))

    except KeyboardInterrupt:

        return ""

# Call main if run as stand-alone executable.

if __name__ == '__main__':

    sys.exit(main())