#============================================================================ 

#Name        : iadinfo.py 

#Part of     : Helium 

#Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

#All rights reserved.

#This component and the accompanying materials are made available

#under the terms of the License "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:

#===============================================================================

import sys, os

import struct

import zlib

PyASN1Availabe = True

try :

    from pyasn1.codec.der import decoder

    from pyasn1.type import base

except :

    PyASN1Availabe = False

def _findItem(item, itemParent, index, objectIdentifier) :

    if isinstance(item, base.AbstractSimpleAsn1Item) :

        if item == objectIdentifier :

            return itemParent[index + 1]

    else:

        for i in range(len(item)) :

            found = _findItem(item[i], item, i, objectIdentifier)

            if found: 

                return found

def findItem(decodedCert, objectIdentifier) :

    return _findItem(decodedCert, None, 0, objectIdentifier)

class CertificateOrganization :

    """ This class holds organisation details of certificate issuer or signer """

    def __init__(self) :

        pass

    def parse(self, decodedCert) :

        self.commonName = findItem(decodedCert, (2, 5, 4, 3))

        self.countryCode = findItem(decodedCert, (2, 5, 4, 6))

        self.locality = findItem(decodedCert, (2, 5, 4, 7))

        self.state = findItem(decodedCert, (2, 5, 4, 8))

        self.street = findItem(decodedCert, (2, 5, 4, 9))

        self.organization = findItem(decodedCert, (2, 5, 4, 10))

    def readableStr(self) :

        buf = ""

        if self.commonName :

            buf += self.commonName.prettyPrint() + "\n"

        if self.countryCode :

            buf += self.countryCode.prettyPrint() + "\n"

        if self.locality :

            buf += self.locality.prettyPrint() + "\n"

        if self.state :

            buf += self.state.prettyPrint() + "\n"

        if self.street :

            buf += self.street.prettyPrint() + "\n"

        if self.organization :

            buf += self.organization.prettyPrint()

        return buf

class CertificateInfo :

    """ This class holds certificate information such as certificate signer and issuer """

    def __init__(self) :

        pass

    def parse(self, decodedCert) :

        self.issuer = CertificateOrganization()

        self.issuer.parse(decodedCert[0][3])

        self.signer = CertificateOrganization()

        self.signer.parse(decodedCert[0][5])

    def readableStr(self) :

        buf = "Signer:\n      " + "\n      ".join(self.signer.readableStr().split('\n')) + "\n"

        buf += "Issuer:\n      " + "\n      ".join(self.issuer.readableStr().split('\n')) + "\n"

        return buf

class SISFileHeader :

    """ Class SIS File header """

    def __init__(self) :

        self.uid1 = 0

        self.uid2 = 0

        self.uid3 = 0

        self.uidChecksum = 0

class SISField :

    """ Class SIS Field """

    def __init__(self) :

        self.type = 0

        self.length = None

        self.subFields = []

    def readFieldLength(self, fileReader) :

        length = fileReader.readBytesAsUint(4)

        if length & 0x80000000 > 0 :

            length = length << 32

            length |= fileReader.readBytesAsUint(4)

        return length

    def findField(self, fieldType, startIndex=0) :

        result = None

        index = startIndex

        for field in self.subFields[startIndex:] :

            if field.type == fieldType :

                result = field

                break

            ++ index

        return (result, index)

    def readableStr(self) :

        return ""

    def traverse(self, handler, depth=0) :

        handler.handleField(self, depth)

        for field in self.subFields :

            field.traverse(handler, depth + 1)

class SISUnsupportedField(SISField) :

    """ Class SIS UnsupportedField """

    def __init__(self) :

        SISField.__init__(self)

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        fileReader.readPlainBytes(self.length)

class SISStringField(SISField) :

    """ Class SIS StringField """

    def __init__(self) :

        SISField.__init__(self)

        self.data = None

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        buf = fileReader.readPlainBytes(self.length)

        self.data = u""

        while len(buf) > 0 :

            temp = buf[:2]

            buf = buf[2:]

            self.data += unichr(ord(temp[0]) | ord(temp[1]) << 8)

    def readableStr(self) :

        return self.data

class SISArrayField(SISField) :

    """ Class SIS ArrayField """

    def __init__(self) :

        SISField.__init__(self)

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        type = fileReader.readBytesAsInt(4)

        l = self.length - 4

        while l > 0 :

            field = SISFieldTypes[type]()

            field.type = type

            field.initFromFile(fileReader)

            self.subFields.append(field)

            l -= field.length + 4 # field length + the length field

            padding = fileReader.skipPadding()

            l -= padding

class SISCompressedField(SISField) :

    """ Class SIS CompressedField """

    def __init__(self) :

        SISField.__init__(self)

        self.algorithm = None

        self.uncompressedDataSize = None

        self.data = None

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        self.algorithm = fileReader.readBytesAsUint(4)

        self.uncompressedDataSize = fileReader.readBytesAsUint(8)

        data = fileReader.readPlainBytes(self.length - 4 - 8)

        if self.algorithm == 0 :

            self.data = data

        elif self.algorithm == 1 :

            self.data = zlib.decompress(data)

class SISVersionField(SISField) :

    """ Class SIS VersionField """

    def __init__(self) :

        SISField.__init__(self)

        self.version = (- 1, - 1, - 1)

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        major = fileReader.readBytesAsInt(4)

        minor = fileReader.readBytesAsInt(4)

        build = fileReader.readBytesAsInt(4)

        self.version = (major, minor, build)

    def readableStr(self) :

        return str(self.version)

class SISVersionRangeField(SISField) :

    """ Class SIS VersionRangeField """

    def __init__(self) :

        SISField.__init__(self)

        self.fromVersion = None

        self.toVersion = None

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        fieldParser = SISFieldParser()

        self.fromVersion = fieldParser.parseField(fileReader)

        if self.length - fieldParser.lastReadBytes > 0  :

            self.toVersion = fieldParser.parseField(fileReader)

class SISDateField(SISField) :

    """ Class SIS DateField """

    def __init__(self) :

        SISField.__init__(self)

        self.year = None

        self.month = None

        self.day = None

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        self.year = fileReader.readBytesAsUint(2)

        self.month = fileReader.readBytesAsUint(1)

        self.day = fileReader.readBytesAsUint(1)

    def readableStr(self) :

        return str(self.year) + "." + str(self.month) + "." + str(self.day)

class SISTimeField(SISField) :

    """ Class SIS TimeField """

    def __init__(self) :

        SISField.__init__(self)

        self.hours = None

        self.minutes = None

        self.seconds = None

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        self.hours = fileReader.readBytesAsUint(1)

        self.minutes = fileReader.readBytesAsUint(1)

        self.seconds = fileReader.readBytesAsUint(1)

    def readableStr(self) :

        return str(self.hours) + ":" + str(self.minutes) + ":" + str(self.seconds)

class SISDateTimeField(SISField) :

    """ Class SIS DateTimeField """

    def __init__(self) :

        SISField.__init__(self)

        self.date = None

        self.time = None

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        fieldParser = SISFieldParser()

        self.date = fieldParser.parseField(fileReader)

        self.time = fieldParser.parseField(fileReader)

class SISUidField(SISField) :

    """ Class SIS UidField """

    def __init__(self) :

        SISField.__init__(self)

        self.uid = None

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        self.uid = fileReader.readBytesAsUint(4)

    def readableStr(self) :

        return hex(self.uid)

class SISLanguageField(SISField) :

    """ Class SIS LanguageField """

    def __init__(self) :

        SISField.__init__(self)

        self.language = None

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        self.language = fileReader.readBytesAsUint(4)

    def readableStr(self) :

        return str(self.language)

class SISContentsField(SISField) :

    """ Class SIS ContentsField """

    def __init__(self) :

        SISField.__init__(self)

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        fieldParser = SISFieldParser()

        field = fieldParser.parseField(fileReader)

        while field :

            if field.type == 3 : # compressed<conroller>

                bufferReader = SISBufferReader(field.data)

                field = fieldParser.parseField(bufferReader)

            self.subFields.append(field)

            field = fieldParser.parseField(fileReader)

class SISControllerField(SISField) :

    """ Class SIS ControllerField """

    def __init__(self) :

        SISField.__init__(self)

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        fieldParser = SISFieldParser()

        bufferReader = SISBufferReader(fileReader.readPlainBytes(self.length))

        field = fieldParser.parseField(bufferReader)

        while field :

            self.subFields.append(field)

            field = fieldParser.parseField(bufferReader)

class SISInfoField(SISField) :

    """ Class SIS InfoField """

    def __init__(self) :

        SISField.__init__(self)

        self.installType = None

        self.installFlags = None

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        fieldParser = SISFieldParser()

        self.subFields.append(fieldParser.parseField(fileReader)) # UID

        self.subFields.append(fieldParser.parseField(fileReader)) # Vendor name unique

        self.subFields.append(fieldParser.parseField(fileReader)) # names

        self.subFields.append(fieldParser.parseField(fileReader)) # vendor names

        self.subFields.append(fieldParser.parseField(fileReader)) # version

        self.subFields.append(fieldParser.parseField(fileReader)) # creation time

        self.installType = fileReader.readBytesAsUint(1)

        self.installFlags = fileReader.readBytesAsUint(1) 

class SISSupportedLanguagesField(SISField) :

    """ Class SISSupportedLanguagesField """

    def __init__(self) :

        SISField.__init__(self)

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        fieldParser = SISFieldParser()

        self.subFields.append(fieldParser.parseField(fileReader)) # languages

class SISSupportedOptionsField(SISField) :

    """ Class SISSupportedOptionsField """

    def __init__(self) :

        SISField.__init__(self)

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        fieldParser = SISFieldParser()

        self.subFields.append(fieldParser.parseField(fileReader)) # options

class SISPrerequisitiesField(SISField) :

    """ Class SISPrerequisitiesField """

    def __init__(self) :

        SISField.__init__(self)

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        fieldParser = SISFieldParser()

        self.subFields.append(fieldParser.parseField(fileReader)) # target devices

        self.subFields.append(fieldParser.parseField(fileReader)) # dependencies

class SISDependencyField(SISField) :

    """ Class SISDependencyField """

    def __init__(self) :

        SISField.__init__(self)

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        fieldParser = SISFieldParser()

        self.subFields.append(fieldParser.parseField(fileReader)) # UID

        field = fieldParser.parseField(fileReader)

        # Version range field is optional

        if field.type == VersionRangeField :

            self.subFields.append(field) # version range

            self.subFields.append(fieldParser.parseField(fileReader)) # dependency names

        else :

            self.subFields.append(field) # dependency names

class SISPropertiesField(SISField) :

    """ Class SISPropertiesField """

    def __init__(self) :

        SISField.__init__(self)

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        fieldParser = SISFieldParser()

        self.subFields.append(fieldParser.parseField(fileReader)) # properties

class SISPropertyField(SISField) :

    """ Class SISPropertyField """

    def __init__(self) :

        SISField.__init__(self)

        self.key = None

        self.value = None

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        self.key = fileReader.readBytesAsInt(4)

        self.value = fileReader.readBytesAsInt(4)

# There is a type for this field, but there is no definition of the field contents

class SISSignaturesField(SISUnsupportedField) :

    """ Class SISSignaturesField """

    pass

class SISCertificateChainField(SISField) :

    """ Class SISCertificateChainField """

    def __init__(self) :

        SISField.__init__(self)

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        fieldParser = SISFieldParser()

        self.subFields.append(fieldParser.parseField(fileReader)) # certificate data

class SISLogoField(SISField) :

    """ Class SISLogoField """

    def __init__(self) :

        SISField.__init__(self)

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        fieldParser = SISFieldParser()

        self.subFields.append(fieldParser.parseField(fileReader)) # logo file

class SISFileDescriptionField(SISField) :

    """ Class SISFileDescriptionField """

    def __init__(self) :

        SISField.__init__(self)

        self.operation = None

        self.operationOptions = None

        self.compressedLength = None

        self.uncompressedLength = None

        self.fileIndex = None

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        fieldParser = SISFieldParser()

        self.subFields.append(fieldParser.parseField(fileReader))

        self.subFields.append(fieldParser.parseField(fileReader))

        field = fieldParser.parseField(fileReader)

        self.subFields.append(field)

        if field.type == 41 : # read field was capabilities ==> there is one more field left

            self.subFields.append(fieldParser.parseField(fileReader))

        self.operation = fileReader.readBytesAsUint(4)

        self.operationOptions = fileReader.readBytesAsUint(4)

        self.compressedLength = fileReader.readBytesAsUint(8)

        self.uncompressedLength = fileReader.readBytesAsUint(8)

        self.fileIndex = fileReader.readBytesAsUint(4)

    def readableStr(self) :

        return "index: " + str(self.fileIndex)

class SISHashField(SISField) :

    """ Class SISHashField """

    def __init__(self) :

        SISField.__init__(self)

        self.algorithm = None

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        fieldParser = SISFieldParser()

        self.algorithm = fileReader.readBytesAsUint(4)

        self.subFields.append(fieldParser.parseField(fileReader)) # logo file

class SISIfField(SISField) :

    """ Class SISIfField """

    def __init__(self) :

        SISField.__init__(self)

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        fieldParser = SISFieldParser()

        self.subFields.append(fieldParser.parseField(fileReader)) # expression

        self.subFields.append(fieldParser.parseField(fileReader)) # install block

        self.subFields.append(fieldParser.parseField(fileReader)) # else ifs

class SISElseIfField(SISField) :

    """ Class SISElseIfField """

    def __init__(self) :

        SISField.__init__(self)

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        fieldParser = SISFieldParser()

        self.subFields.append(fieldParser.parseField(fileReader)) # expression

        self.subFields.append(fieldParser.parseField(fileReader)) # install block

class SISInstallBlockField(SISField) :

    """ Class SISInstallBlockField """

    def __init__(self) :

        SISField.__init__(self)

        self.files = None

        self.embeddedSISFiles = None

        self.ifBlocks = None

    def initFromFile(self, fileReader) :

        self.length = self.readFieldLength(fileReader)

        fieldParser = SISFieldParser()

        self.subFields.append(fieldParser.parseField(fileReader))

        self.subFields.append(fieldParser.parseField(fileReader))

        self.subFields.append(fieldParser.parseField(fileReader))

class SISExpressionField(SISField) :

    """ Class SISExpressionField """

    def __init__(self) :