#
# Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
# All rights reserved.
# This component and the accompanying materials are made available
# under the terms of "Eclipse Public License v1.0"
# which accompanies this distribution, and is available
# at the URL "http://www.eclipse.org/legal/epl-v10.html".
#
# Initial Contributors:
# Nokia Corporation - initial contribution.
#
# Contributors:
#
# Description:
# Generate checksums for different types of files
#

import sys
import os
import re
import struct
import subprocess
import platform
try:
    from hashlib import md5
except ImportError:
    import md5

import SymbianUtils

class Evalid(object):
    '''
    Provide some of the functionality found in epoc32/tools/EvalidCompare.pm

    generateSignature() - use appropriate method to calculate checksum for a file
    getUid() - extract Uid from file
    '''

    class ExternalError(SymbianUtils.SymbianUtilsError):
        """ An external utility exited with an error """

    ext = ".exe" if platform.system() == "Windows" else ""
    binPath = os.path.normpath(os.path.join(os.path.dirname(__file__), "bin"))
    NM = os.path.join(binPath, "nm" + ext)
    ELFDUMP = os.path.join(binPath, "elfdump" + ext)
    ELF2E32 = os.path.join(binPath, "elf2e32" + ext)
    PE_DUMP = os.path.join(binPath, "pe_dump" + ext)

    ELF_DLL_NAME = re.compile(r"#<DLL>(\S+\.\S+)#<\\DLL>")
    ELF_DEBUG = re.compile(r"^\.(rel\.)?debug_")
    ELF_P_HEAD = re.compile(r"^\tProgram header offset.*$")
    ELF_S_HEAD = re.compile(r"^\tSection header offset.*$")
    PRECOMP_IGNORE = re.compile(r'^# \d+ ".*"( \d)?$')
    E32_EMPTY = re.compile("Time Stamp:|E32ImageFile|Header CRC:")
    E32_LOWER = re.compile("imports from")
    INTEL_OBJECTPATH_WIN  = re.compile(r"\.\.\\[^(]*\\")
    INTEL_OBJECTPATH_NIX  = re.compile("\.\.\/[^(]*\/")
    INTEL_DLLTOOL = re.compile("^(.+ (_head|_))\w+_(EPOC32_\w+(_LIB|_iname))$", re.I)

    @classmethod
    def typeLookup(cls, type):
        '''
        Return the internally used identifier string for the type
        @todo: Warning
        @param type: The type
        @type type: String
        @return: Internally used type identifier
        @rtype: String
        '''
        if type in ("e32", "default", "elf", "preprocessed_text", "intel", "intel_pe"):
            return type
        elif type in ("file", "symbol"):
            return "default"
        elif type in ("staticlib", "dso"):
            return "elf"
        elif type in ("exe", "plugin", "dll"):
            return "e32"
        else:
            #sys.stderr.write("warning - unknown hashtype %s.\n"%type)
            return "default"

    @classmethod
    def generateSignature(cls, path, fileType):
        '''
        Generic dispatcher method for file types. Use the appropriate method for
        I{type} to generate the signature for file at I{path}.

        @param path: The path where the file is located
        @type path: String
        @return: checksum
        @rtype: String
        '''
        if not isinstance(path, basestring):
            raise TypeError, "path must be a string"
        if not path:
            raise ValueError, "path must not be zero length"
        path = os.path.normpath(path)
        fileType = cls.typeLookup(fileType)
        methodName = "sig_" + fileType
        if hasattr(cls, methodName):
            method = getattr(cls, methodName)
            return method(path)
        else:
            raise NotImplementedError("No signature generator for type %s" % fileType)

    @staticmethod
    def getUid(index, file):
        '''Get UID of file

        @param index: Which UID
        @param file: Absolute path
        @return: UID
        @rtype: String
        '''
        if index not in (1, 2, 3):
            raise ValueError("Index can only be one of 1, 2 or 3")
        if os.path.getsize(file) < 12:
            return None
        start = (index-1) * 4
        finish = start + 4
        f = open(file, "rb")
        head = f.read(12)
        f.close()
        return struct.unpack("<l", head[start:finish])[0]

    @staticmethod
    def getMd5():
        '''A convenicence method to use appropriate library regardless of Python
        version. Maintain compatibility while using hashlib whenever possible.

        @return: md5 object
        @rtype: md5
        '''
        if hasattr(md5, "new"):
            return md5.new()
        else:
            return md5()

    # Signatures for various formats

    @classmethod
    def sig_e32(cls, path):
        '''
        Return the checksum of significant parts using elf2e32

        @param path: The absolute path
        @type path: String
        @return: checksum
        @rtype: String
        '''
        bin = cls.ELF2E32 + " --dump --e32input="
        m = cls.getMd5()
        fo = os.popen(bin+path, "r", -1)
        for line in fo:
            if cls.E32_EMPTY.search(line):
                line = ""
            if cls.E32_LOWER.search(line):
                line = line.lower()
            m.update(line)
        if fo.close():
            raise cls.ExternalError("elf2e32 failed at %s" % path)
        return m.hexdigest()

    @classmethod
    def sig_default(cls, path):
        '''
        Calculate the checksum of the file without filtering.

        @param path: The absolute path
        @type path: String
        @return: checksum
        @rtype: String
        '''
        m = cls.getMd5()
        f = open(path, "rb")
        while True:
            buf = f.read(32*1024)
            if not buf:
                break
            m.update(buf)
        f.close()
        return m.hexdigest()

    @classmethod
    def sig_elf(cls, path):
        '''
        Return the checksum of significant parts using elfdump

        @param path: The absolute path
        @type path: String
        @return: checksum
        @rtype: String
        '''
        bin = cls.ELFDUMP + " -i "
        def firstGroupToLc(match):
            return ("#<DLL>" + match.group(1).lower() + "#<\\DLL>")
        m = cls.getMd5()
        fo = os.popen(bin+path, "r", -1)
        for line in fo:
            if cls.ELF_P_HEAD.match(line):
                line = "Program header offset\n"
            if cls.ELF_S_HEAD.match(line):
                line = "Section header offset\n"
            line = cls.ELF_DLL_NAME.sub(firstGroupToLc, line)
            if cls.ELF_DEBUG.match(line):
                line = ""
            #sys.stderr.write(line)
            m.update(line)
        if fo.close():
            raise cls.ExternalError("elfdump failed at %s" % path)
        return m.hexdigest()

    @classmethod
    def sig_preprocessed_text(cls, path):
        '''
        Return the checksum of significant parts of preprocessed text

        @param path: The absolute path
        @type path: String
        @return: checksum
        @rtype: String
        '''
        m = cls.getMd5()
        f = open(path, "rb")
        for line in f:
            line = line.replace("\r\n", "\n")
            if cls.PRECOMP_IGNORE.search(line):
                line = "\n"
            m.update(line)
        f.close()
        return m.hexdigest()

    @classmethod
    def sig_intel_pe(cls, path):
        '''
        Return the checksum of significant parts of pe_dump output

        @param path: The absolute path
        @type path: String
        @return: checksum
        @rtype: String
        '''
        m = cls.getMd5()
        fo = os.popen("%s %s" % (cls.PE_DUMP, path), "r", -1)
        for line in fo:
            m.update(line)
        if fo.close():
            raise cls.ExternalError("pe_dump failed at %s" % path)
        return m.hexdigest()


    @classmethod
    def sig_intel(cls, path):
        '''
        Return the checksum of significant parts using nm

        @param path: The absolute path
        @type path: String
        @return: checksum
        @rtype: String
        '''
        m = cls.getMd5()
        try:
            s = subprocess.Popen([cls.NM, "--no-sort", path], env=None, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            out, err = s.communicate()
        except OSError, e:
            raise cls.ExternalError, "nm failed at %s: %s" % (path, str(e))
        if s.returncode != 0:
            raise cls.ExternalError, "nm failed at %s: %s" % (path, err)
        for line in out.splitlines():
            # no need for regexps here
            if line.endswith(":\n") \
                or line.startswith("BFD: ") \
                or cls.INTEL_OBJECTPATH_WIN.search(line) \
                or cls.INTEL_OBJECTPATH_NIX.search(line):
                line = "\n"
            match = cls.INTEL_DLLTOOL.search(line)
            if match:
                line = "%s_..._%s" % (match.groups()[0], match.groups()[2])
                line = line.upper()
            m.update(line)

        if s.returncode != 0:
            raise cls.ExternalError("nm failed at %s" % path)
        return m.hexdigest()

def main():
    path = sys.argv[1]
    ftype = sys.argv[2]
    print Evalid.generateSignature(path, ftype)

if __name__ == "__main__":
    main()