diff -r c7c26511138f -r 7c4a911dc066 buildframework/helium/sf/python/pythoncore/lib/iadinfo.py --- a/buildframework/helium/sf/python/pythoncore/lib/iadinfo.py Wed Jun 16 16:51:40 2010 +0300 +++ b/buildframework/helium/sf/python/pythoncore/lib/iadinfo.py Fri Aug 13 14:59:05 2010 +0300 @@ -1,6 +1,6 @@ #============================================================================ -#Name : iadinfo.py -#Part of : Helium +#Name : iadinfo.py +#Part of : Helium #Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). #All rights reserved. @@ -24,34 +24,39 @@ PyASN1Availabe = True -try : +try: from pyasn1.codec.der import decoder from pyasn1.type import base except ImportError: PyASN1Availabe = False -def _findItem(item, itemParent, index, objectIdentifier) : +def _findItem(item, itemParent, index, objectIdentifier): """find Item""" - if isinstance(item, base.AbstractSimpleAsn1Item) : - if item == objectIdentifier : + if isinstance(item, base.AbstractSimpleAsn1Item): + if item == objectIdentifier: return itemParent[index + 1] else: - for i_item in range(len(item)) : + for i_item in range(len(item)): found = _findItem(item[i_item], item, i_item, objectIdentifier) if found: return found -def findItem(decodedCert, objectIdentifier) : +def findItem(decodedCert, objectIdentifier): """find item""" return _findItem(decodedCert, None, 0, objectIdentifier) -class CertificateOrganization : +class CertificateOrganization: """ This class holds organisation details of certificate issuer or signer """ - def __init__(self) : - pass - - def parse(self, decodedCert) : + def __init__(self): + self.commonName = None + self.countryCode = None + self.locality = None + self.state = None + self.street = None + self.organization = None + + def parse(self, decodedCert): """parse certificate Organisation""" self.commonName = findItem(decodedCert, (2, 5, 4, 3)) self.countryCode = findItem(decodedCert, (2, 5, 4, 6)) @@ -60,29 +65,30 @@ self.street = findItem(decodedCert, (2, 5, 4, 9)) self.organization = findItem(decodedCert, (2, 5, 4, 10)) - def readableStr(self) : + def readableStr(self): """readable String""" buf = "" - if self.commonName : + if self.commonName: buf += self.commonName.prettyPrint() + "\n" - if self.countryCode : + if self.countryCode: buf += self.countryCode.prettyPrint() + "\n" - if self.locality : + if self.locality: buf += self.locality.prettyPrint() + "\n" - if self.state : + if self.state: buf += self.state.prettyPrint() + "\n" - if self.street : + if self.street: buf += self.street.prettyPrint() + "\n" - if self.organization : + if self.organization: buf += self.organization.prettyPrint() return buf -class CertificateInfo : +class CertificateInfo: """ This class holds certificate information such as certificate signer and issuer """ - def __init__(self) : - pass + def __init__(self): + self.issuer = None + self.signer = None - def parse(self, decodedCert) : + def parse(self, decodedCert): """parse""" self.issuer = CertificateOrganization() self.issuer.parse(decodedCert[0][3]) @@ -90,101 +96,101 @@ self.signer = CertificateOrganization() self.signer.parse(decodedCert[0][5]) - def readableStr(self) : + def readableStr(self): """readable String""" 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 SISFileHeader: """ Class SIS File header """ - def __init__(self) : + def __init__(self): self.uid1 = 0 self.uid2 = 0 self.uid3 = 0 self.uidChecksum = 0 -class SISField : +class SISField: """ Class SIS Field """ - def __init__(self) : - self.type = 0 + def __init__(self): + self.type_ = 0 self.length = None self.subFields = [] - def readFieldLength(self, fileReader) : + def readFieldLength(self, fileReader): """read Field Length""" length = fileReader.readBytesAsUint(4) - if length & 0x80000000 > 0 : + if length & 0x80000000 > 0: length = length << 32 length |= fileReader.readBytesAsUint(4) return length - def findField(self, fieldType, startIndex=0) : + def findField(self, fieldType, startIndex=0): """find Field""" result = None index = startIndex - for field in self.subFields[startIndex:] : - if field.type == fieldType : + for field in self.subFields[startIndex:]: + if field.type_ == fieldType: result = field break - ++ index + index = index + 1 return (result, index) - def readableStr(self) : + def readableStr(self): """readable String""" return "" - def traverse(self, handler, depth=0) : + def traverse(self, handler, depth=0): """ traverse""" handler.handleField(self, depth) - for field in self.subFields : + for field in self.subFields: field.traverse(handler, depth + 1) -class SISUnsupportedField(SISField) : +class SISUnsupportedField(SISField): """ Class SIS UnsupportedField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialisation From File""" self.length = self.readFieldLength(fileReader) fileReader.readPlainBytes(self.length) -class SISStringField(SISField) : +class SISStringField(SISField): """ Class SIS StringField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) self.data = None - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) buf = fileReader.readPlainBytes(self.length) self.data = u"" - while len(buf) > 0 : + while len(buf) > 0: temp = buf[:2] buf = buf[2:] self.data += unichr(ord(temp[0]) | ord(temp[1]) << 8) - def readableStr(self) : + def readableStr(self): """readable String""" return self.data -class SISArrayField(SISField) : +class SISArrayField(SISField): """ Class SIS ArrayField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) - type = fileReader.readBytesAsInt(4) + type_ = fileReader.readBytesAsInt(4) l_len = self.length - 4 - while l_len > 0 : - field = SISFieldTypes[type]() - field.type = type + while l_len > 0: + field = SISFieldTypes[type_]() + field.type_ = type_ field.initFromFile(fileReader) self.subFields.append(field) @@ -192,32 +198,32 @@ padding = fileReader.skipPadding() l_len -= padding -class SISCompressedField(SISField) : +class SISCompressedField(SISField): """ Class SIS CompressedField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) self.algorithm = None self.uncompressedDataSize = None self.data = None - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" 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 : + if self.algorithm == 0: self.data = data - elif self.algorithm == 1 : + elif self.algorithm == 1: self.data = zlib.decompress(data) -class SISVersionField(SISField) : +class SISVersionField(SISField): """ Class SIS VersionField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) self.version = (- 1, - 1, - 1) - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) major = fileReader.readBytesAsInt(4) @@ -225,147 +231,147 @@ build = fileReader.readBytesAsInt(4) self.version = (major, minor, build) - def readableStr(self) : + def readableStr(self): """readable string""" return str(self.version) -class SISVersionRangeField(SISField) : +class SISVersionRangeField(SISField): """ Class SIS VersionRangeField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) self.fromVersion = None self.toVersion = None - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() self.fromVersion = fieldParser.parseField(fileReader) - if self.length - fieldParser.lastReadBytes > 0 : + if self.length - fieldParser.lastReadBytes > 0 : self.toVersion = fieldParser.parseField(fileReader) -class SISDateField(SISField) : +class SISDateField(SISField): """ Class SIS DateField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) self.year = None self.month = None self.day = None - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise from File""" self.length = self.readFieldLength(fileReader) self.year = fileReader.readBytesAsUint(2) self.month = fileReader.readBytesAsUint(1) self.day = fileReader.readBytesAsUint(1) - def readableStr(self) : + def readableStr(self): """readable string""" return str(self.year) + "." + str(self.month) + "." + str(self.day) -class SISTimeField(SISField) : +class SISTimeField(SISField): """ Class SIS TimeField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) self.hours = None self.minutes = None self.seconds = None - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise from File""" self.length = self.readFieldLength(fileReader) self.hours = fileReader.readBytesAsUint(1) self.minutes = fileReader.readBytesAsUint(1) self.seconds = fileReader.readBytesAsUint(1) - def readableStr(self) : + def readableStr(self): """readable String""" return str(self.hours) + ":" + str(self.minutes) + ":" + str(self.seconds) -class SISDateTimeField(SISField) : +class SISDateTimeField(SISField): """ Class SIS DateTimeField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) self.date = None self.time = None - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() self.date = fieldParser.parseField(fileReader) self.time = fieldParser.parseField(fileReader) -class SISUidField(SISField) : +class SISUidField(SISField): """ Class SIS UidField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) self.uid = None - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) self.uid = fileReader.readBytesAsUint(4) - def readableStr(self) : + def readableStr(self): """readable String""" return hex(self.uid) -class SISLanguageField(SISField) : +class SISLanguageField(SISField): """ Class SIS LanguageField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) self.language = None - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) self.language = fileReader.readBytesAsUint(4) - def readableStr(self) : + def readableStr(self): """readable String""" return str(self.language) -class SISContentsField(SISField) : +class SISContentsField(SISField): """ Class SIS ContentsField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() field = fieldParser.parseField(fileReader) - while field : - if field.type == 3 : # compressed + while field: + if field.type_ == 3: # compressed bufferReader = SISBufferReader(field.data) field = fieldParser.parseField(bufferReader) self.subFields.append(field) field = fieldParser.parseField(fileReader) -class SISControllerField(SISField) : +class SISControllerField(SISField): """ Class SIS ControllerField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() bufferReader = SISBufferReader(fileReader.readPlainBytes(self.length)) field = fieldParser.parseField(bufferReader) - while field : + while field: self.subFields.append(field) field = fieldParser.parseField(bufferReader) -class SISInfoField(SISField) : +class SISInfoField(SISField): """ Class SIS InfoField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) self.installType = None self.installFlags = None - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() @@ -378,34 +384,34 @@ self.installType = fileReader.readBytesAsUint(1) self.installFlags = fileReader.readBytesAsUint(1) -class SISSupportedLanguagesField(SISField) : +class SISSupportedLanguagesField(SISField): """ Class SISSupportedLanguagesField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() self.subFields.append(fieldParser.parseField(fileReader)) # languages -class SISSupportedOptionsField(SISField) : +class SISSupportedOptionsField(SISField): """ Class SISSupportedOptionsField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() self.subFields.append(fieldParser.parseField(fileReader)) # options -class SISPrerequisitiesField(SISField) : +class SISPrerequisitiesField(SISField): """ Class SISPrerequisitiesField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() @@ -413,77 +419,77 @@ self.subFields.append(fieldParser.parseField(fileReader)) # dependencies -class SISDependencyField(SISField) : +class SISDependencyField(SISField): """ Class SISDependencyField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" 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 : + if field.type_ == VersionRangeField: self.subFields.append(field) # version range self.subFields.append(fieldParser.parseField(fileReader)) # dependency names - else : + else: self.subFields.append(field) # dependency names -class SISPropertiesField(SISField) : +class SISPropertiesField(SISField): """ Class SISPropertiesField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() self.subFields.append(fieldParser.parseField(fileReader)) # properties -class SISPropertyField(SISField) : +class SISPropertyField(SISField): """ Class SISPropertyField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) self.key = None self.value = None - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) self.key = fileReader.readBytesAsInt(4) self.value = fileReader.readBytesAsInt(4) -class SISSignaturesField(SISUnsupportedField) : +class SISSignaturesField(SISUnsupportedField): """ Class SISSignaturesField There is a type for this field, but there is no definition of the field contents""" pass -class SISCertificateChainField(SISField) : +class SISCertificateChainField(SISField): """ Class SISCertificateChainField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() self.subFields.append(fieldParser.parseField(fileReader)) # certificate data -class SISLogoField(SISField) : +class SISLogoField(SISField): """ Class SISLogoField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() self.subFields.append(fieldParser.parseField(fileReader)) # logo file -class SISFileDescriptionField(SISField) : +class SISFileDescriptionField(SISField): """ Class SISFileDescriptionField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) self.operation = None self.operationOptions = None @@ -491,7 +497,7 @@ self.uncompressedLength = None self.fileIndex = None - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() @@ -500,7 +506,7 @@ 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 + 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) @@ -509,29 +515,29 @@ self.uncompressedLength = fileReader.readBytesAsUint(8) self.fileIndex = fileReader.readBytesAsUint(4) - def readableStr(self) : + def readableStr(self): """readable string""" return "index: " + str(self.fileIndex) -class SISHashField(SISField) : +class SISHashField(SISField): """ Class SISHashField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) self.algorithm = None - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" 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(SISField): """ Class SISIfField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() @@ -539,27 +545,27 @@ self.subFields.append(fieldParser.parseField(fileReader)) # install block self.subFields.append(fieldParser.parseField(fileReader)) # else ifs -class SISElseIfField(SISField) : +class SISElseIfField(SISField): """ Class SISElseIfField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" 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(SISField): """ Class SISInstallBlockField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) self.files = None self.embeddedSISFiles = None self.ifBlocks = None - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() @@ -567,212 +573,212 @@ self.subFields.append(fieldParser.parseField(fileReader)) self.subFields.append(fieldParser.parseField(fileReader)) -class SISExpressionField(SISField) : +class SISExpressionField(SISField): """ Class SISExpressionField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) self.operator = None self.integerValue = None - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() self.operator = fileReader.readBytesAsUint(4) self.integerValue = fileReader.readBytesAsInt(4) - if self.operator == 10 or self.operator == 13 : + if self.operator == 10 or self.operator == 13: self.subFields.append(fieldParser.parseField(fileReader)) - if self.operator == 1 or self.operator == 2 or self.operator == 3 or self.operator == 4 or self.operator == 5 or self.operator == 6 or self.operator == 7 or self.operator == 8 or self.operator == 11 or self.operator == 12 : + if self.operator == 1 or self.operator == 2 or self.operator == 3 or self.operator == 4 or self.operator == 5 or self.operator == 6 or self.operator == 7 or self.operator == 8 or self.operator == 11 or self.operator == 12: self.subFields.append(fieldParser.parseField(fileReader)) - if not (self.operator == 13 or self.operator == 14 or self.operator == 15 or self.operator == 16 or self.operator == 10) : + if not (self.operator == 13 or self.operator == 14 or self.operator == 15 or self.operator == 16 or self.operator == 10): self.subFields.append(fieldParser.parseField(fileReader)) -class SISDataField(SISField) : +class SISDataField(SISField): """ Class SISDataField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() self.subFields.append(fieldParser.parseField(fileReader)) # data units -class SISDataUnitField(SISField) : +class SISDataUnitField(SISField): """ Class SISDataUnitField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() self.subFields.append(fieldParser.parseField(fileReader)) # file data -class SISFileDataField(SISField) : +class SISFileDataField(SISField): """ Class SISFileDataField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() self.subFields.append(fieldParser.parseField(fileReader)) # raw file data -class SISSupportedOptionField(SISField) : +class SISSupportedOptionField(SISField): """ Class SISSupportedOptionField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() self.subFields.append(fieldParser.parseField(fileReader)) # names -class SISControllerChecksumField(SISField) : +class SISControllerChecksumField(SISField): """ Class SISControllerChecksumField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) self.checksum = None - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) self.checksum = fileReader.readBytesAsUint(2) -class SISDataChecksumField(SISField) : +class SISDataChecksumField(SISField): """ Class SISDataChecksumField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) self.checksum = None - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) self.checksum = fileReader.readBytesAsUint(2) -class SISSignatureField(SISField) : +class SISSignatureField(SISField): """ Class SISSignatureField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() self.subFields.append(fieldParser.parseField(fileReader)) # signature algorithm self.subFields.append(fieldParser.parseField(fileReader)) # signature data -class SISBlobField(SISField) : +class SISBlobField(SISField): """ Class SISBlobField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) self.data = None - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) self.data = fileReader.readPlainBytes(self.length) -class SISSignatureAlgorithmField(SISField) : +class SISSignatureAlgorithmField(SISField): """ Class SISSignatureAlgorithmField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() self.subFields.append(fieldParser.parseField(fileReader)) # algorithm identifier -class SISSignatureCertificateChainField(SISField) : +class SISSignatureCertificateChainField(SISField): """ Class SISSignatureCertificateChainField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) fieldParser = SISFieldParser() self.subFields.append(fieldParser.parseField(fileReader)) # signatures self.subFields.append(fieldParser.parseField(fileReader)) # certificate chain -class SISDataIndexField(SISField) : +class SISDataIndexField(SISField): """ Class SISDataIndexField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) self.dataIndex = None - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) self.dataIndex = fileReader.readBytesAsUint(4) -class SISCapabilitiesField(SISField) : +class SISCapabilitiesField(SISField): """ Class SISCapabilitiesField """ - def __init__(self) : + def __init__(self): SISField.__init__(self) self.capabilities = 0 self.readableCaps = [] - def initFromFile(self, fileReader) : + def initFromFile(self, fileReader): """initialise From File""" self.length = self.readFieldLength(fileReader) self.capabilities = fileReader.readBytesAsUint(self.length) - for i in range(20) : - if (self.capabilities >> i) & 0x01 : + for i in range(20): + if (self.capabilities >> i) & 0x01: self.readableCaps.append(CapabilityNames[i]) - def readableStr(self) : + def readableStr(self): """readable string""" return " ".join(self.readableCaps) SISFieldTypes = { - 1 : SISStringField, - 2 : SISArrayField, - 3 : SISCompressedField, - 4 : SISVersionField, - 5 : SISVersionRangeField, - 6 : SISDateField, - 7 : SISTimeField, - 8 : SISDateTimeField, - 9 : SISUidField, - 10 : SISUnsupportedField, - 11 : SISLanguageField, - 12 : SISContentsField, - 13 : SISControllerField, - 14 : SISInfoField, - 15 : SISSupportedLanguagesField, - 16 : SISSupportedOptionsField, - 17 : SISPrerequisitiesField, - 18 : SISDependencyField, - 19 : SISPropertiesField, - 20 : SISPropertyField, - 21 : SISSignaturesField, - 22 : SISCertificateChainField, - 23 : SISLogoField, - 24 : SISFileDescriptionField, - 25 : SISHashField, - 26 : SISIfField, - 27 : SISElseIfField, - 28 : SISInstallBlockField, - 29 : SISExpressionField, - 30 : SISDataField, - 31 : SISDataUnitField, - 32 : SISFileDataField, - 33 : SISSupportedOptionField, - 34 : SISControllerChecksumField, - 35 : SISDataChecksumField, - 36 : SISSignatureField, - 37 : SISBlobField, - 38 : SISSignatureAlgorithmField, - 39 : SISSignatureCertificateChainField, - 40 : SISDataIndexField, - 41 : SISCapabilitiesField + 1: SISStringField, + 2: SISArrayField, + 3: SISCompressedField, + 4: SISVersionField, + 5: SISVersionRangeField, + 6: SISDateField, + 7: SISTimeField, + 8: SISDateTimeField, + 9: SISUidField, + 10: SISUnsupportedField, + 11: SISLanguageField, + 12: SISContentsField, + 13: SISControllerField, + 14: SISInfoField, + 15: SISSupportedLanguagesField, + 16: SISSupportedOptionsField, + 17: SISPrerequisitiesField, + 18: SISDependencyField, + 19: SISPropertiesField, + 20: SISPropertyField, + 21: SISSignaturesField, + 22: SISCertificateChainField, + 23: SISLogoField, + 24: SISFileDescriptionField, + 25: SISHashField, + 26: SISIfField, + 27: SISElseIfField, + 28: SISInstallBlockField, + 29: SISExpressionField, + 30: SISDataField, + 31: SISDataUnitField, + 32: SISFileDataField, + 33: SISSupportedOptionField, + 34: SISControllerChecksumField, + 35: SISDataChecksumField, + 36: SISSignatureField, + 37: SISBlobField, + 38: SISSignatureAlgorithmField, + 39: SISSignatureCertificateChainField, + 40: SISDataIndexField, + 41: SISCapabilitiesField } [StringField, @@ -818,71 +824,71 @@ CapabilitiesField] = range(1, 42) FieldNames = { - 0 : "ROOT", - StringField : "StringField", - ArrayField : "ArrayField", - CompressedField : "CompressedField", - VersionField : "VersionField", - VersionRangeField : "VersionRangeField", - DateField : "DateField", - TimeField : "TimeField", - DateTimeField : "DateTimeField", - UidField : "UidField", - UnusedField : "UnusedField", - LanguageField : "LanguageField", - ContentsField : "ContentsField", - ControllerField : "ControllerField", - InfoField : "InfoField", - SupportedLanguagesField : "SupportedLanguagesField", - SupportedOptionsField : "SupportedOptionsField", - PrerequisitiesField : "PrerequisitiesField", - DependencyField : "DependencyField", - PropertiesField : "PropertiesField", - PropertyField : "PropertyField", - SignaturesField : "SignaturesField", - CertificateChainField : "CertificateChainField", - LogoField : "LogoField", - FileDescriptionField : "FileDescriptionField", - HashField : "HashField", - IfField : "IfField", - ElseIfField : "ElseIfField", - InstallBlockField : "InstallBlockField", - ExpressionField : "ExpressionField", - DataField : "DataField", - DataUnitField : "DataUnitField", - FileDataField : "FileDataField", - SupportedOptionField : "SupportedOptionField", - ControllerChecksumField : "ControllerChecksumField", - DataChecksumField : "DataChecksumField", - SignatureField : "SignatureField", - BlobField : "BlobField", - SignatureAlgorithmField : "SignatureAlgorithmField", - SignatureCertificateChainField : "SignatureCertificateChainField", - DataIndexField : "DataIndexField", - CapabilitiesField : "CapabilitiesField" + 0: "ROOT", + StringField: "StringField", + ArrayField: "ArrayField", + CompressedField: "CompressedField", + VersionField: "VersionField", + VersionRangeField: "VersionRangeField", + DateField: "DateField", + TimeField: "TimeField", + DateTimeField: "DateTimeField", + UidField: "UidField", + UnusedField: "UnusedField", + LanguageField: "LanguageField", + ContentsField: "ContentsField", + ControllerField: "ControllerField", + InfoField: "InfoField", + SupportedLanguagesField: "SupportedLanguagesField", + SupportedOptionsField: "SupportedOptionsField", + PrerequisitiesField: "PrerequisitiesField", + DependencyField: "DependencyField", + PropertiesField: "PropertiesField", + PropertyField: "PropertyField", + SignaturesField: "SignaturesField", + CertificateChainField: "CertificateChainField", + LogoField: "LogoField", + FileDescriptionField: "FileDescriptionField", + HashField: "HashField", + IfField: "IfField", + ElseIfField: "ElseIfField", + InstallBlockField: "InstallBlockField", + ExpressionField: "ExpressionField", + DataField: "DataField", + DataUnitField: "DataUnitField", + FileDataField: "FileDataField", + SupportedOptionField: "SupportedOptionField", + ControllerChecksumField: "ControllerChecksumField", + DataChecksumField: "DataChecksumField", + SignatureField: "SignatureField", + BlobField: "BlobField", + SignatureAlgorithmField: "SignatureAlgorithmField", + SignatureCertificateChainField: "SignatureCertificateChainField", + DataIndexField: "DataIndexField", + CapabilitiesField: "CapabilitiesField" } CapabilityNames = { - 0 : "TCB", - 1 : "CommDD", - 2 : "PowerMgmt", - 3 : "MultimediaDD", - 4 : "ReadDeviceData", - 5 : "WriteDeviceData", - 6 : "DRM", - 7 : "TrustedUI", - 8 : "ProtServ", - 9 : "DiskAdmin", - 10 : "NetworkControl", - 11 : "AllFiles", - 12 : "SwEvent", - 13 : "NetworkServices", - 14 : "LocalServices", - 15 : "ReadUserData", - 16 : "WriteUserData", - 17 : "Location", - 18 : "SurroundingsDD", - 19 : "UserEnvironment" + 0: "TCB", + 1: "CommDD", + 2: "PowerMgmt", + 3: "MultimediaDD", + 4: "ReadDeviceData", + 5: "WriteDeviceData", + 6: "DRM", + 7: "TrustedUI", + 8: "ProtServ", + 9: "DiskAdmin", + 10: "NetworkControl", + 11: "AllFiles", + 12: "SwEvent", + 13: "NetworkServices", + 14: "LocalServices", + 15: "ReadUserData", + 16: "WriteUserData", + 17: "Location", + 18: "SurroundingsDD", + 19: "UserEnvironment" } InstallTypes = { @@ -893,86 +899,86 @@ 4: "PP" } -class SISReader : +class SISReader: """ SIS Reader """ - def __init__(self) : + def __init__(self): self.bytesRead = 0 - def readUnsignedBytes(self, numBytes) : + def readUnsignedBytes(self, numBytes): """read Unsigned bytes""" buf = self.readPlainBytes(numBytes) - if len(buf) < numBytes : + if len(buf) < numBytes: return [] - format = "" - for _ in range(numBytes) : - format += "B" - return struct.unpack(format, buf) + format_ = "" + for _ in range(numBytes): + format_ += "B" + return struct.unpack(format_, buf) - def readSignedBytes(self, numBytes) : + def readSignedBytes(self, numBytes): """read signed bytes""" buf = self.readPlainBytes(numBytes) - if len(buf) < numBytes : + if len(buf) < numBytes: return [] - format = "" - for _ in range(numBytes) : - format += "b" - return struct.unpack(format, buf) + format_ = "" + for _ in range(numBytes): + format_ += "b" + return struct.unpack(format_, buf) - def readBytesAsUint(self, numBytes) : + def readBytesAsUint(self, numBytes): """read bytes as Unit""" result = 0 - bytes = self.readUnsignedBytes(numBytes) - if len(bytes) == numBytes : - for i_byte in range(numBytes) : - result |= bytes[i_byte] << (i_byte * 8) + bytes_ = self.readUnsignedBytes(numBytes) + if len(bytes_) == numBytes: + for i_byte in range(numBytes): + result |= bytes_[i_byte] << (i_byte * 8) return result - def readBytesAsInt(self, numBytes) : + def readBytesAsInt(self, numBytes): """read bytes as Integer""" result = 0 - bytes = self.readSignedBytes(numBytes) - if len(bytes) == numBytes : - for i_byte in range(numBytes) : - result |= bytes[i_byte] << (i_byte * 8) + bytes_ = self.readSignedBytes(numBytes) + if len(bytes_) == numBytes: + for i_byte in range(numBytes): + result |= bytes_[i_byte] << (i_byte * 8) return result - def skipPadding(self) : + def skipPadding(self): """skip padding""" result = 0 - if self.bytesRead % 4 != 0 : + if self.bytesRead % 4 != 0: paddingLength = 4 - self.bytesRead % 4 self.readPlainBytes(paddingLength) result = paddingLength return result - def readPlainBytes(self, numBytes) : + def readPlainBytes(self, numBytes): """read plain bytes""" pass -class SISFileReader(SISReader) : +class SISFileReader(SISReader): """ SIS File Reader """ - def __init__(self, inStream) : + def __init__(self, inStream): SISReader.__init__(self) self.inStream = inStream self.eof = False self.bytesRead = 0 - def readPlainBytes(self, numBytes) : + def readPlainBytes(self, numBytes): """read Plain byytes""" - if self.eof : + if self.eof: return "" - if numBytes == 0 : + if numBytes == 0: return "" buf = "" buf = self.inStream.read(numBytes) - if len(buf) < numBytes : + if len(buf) < numBytes: self.eof = True return "" @@ -980,121 +986,122 @@ return buf - def isEof(self) : + def isEof(self): """is it End of File""" return self.eof -class SISBufferReader(SISReader) : +class SISBufferReader(SISReader): """ SIS Buffer reader """ - def __init__(self, buffer) : - self.buffer = buffer + def __init__(self, buffer_): + SISReader.__init__(self) + self.buffer_ = buffer_ self.bytesRead = 0 - def readPlainBytes(self, numBytes) : + def readPlainBytes(self, numBytes): """read Plain bytes""" - if self.isEof() : + if self.isEof(): return "" - if numBytes == 0 : + if numBytes == 0: return "" - result = self.buffer[self.bytesRead:self.bytesRead + numBytes] + result = self.buffer_[self.bytesRead:self.bytesRead + numBytes] self.bytesRead += numBytes return result - def isEof(self) : + def isEof(self): """is it End of File""" - return self.bytesRead >= len(self.buffer) + return self.bytesRead >= len(self.buffer_) -class SISFieldParser : +class SISFieldParser: """ Parser to read a SIS field """ - def __init__(self) : + def __init__(self): self.lastReadBytes = 0 - def parseField(self, fileReader) : + def parseField(self, fileReader): """Reads the next field from the fileReader stream and returns it""" field = None self.lastReadBytes = 0 - type = fileReader.readBytesAsUint(4) + type_ = fileReader.readBytesAsUint(4) self.lastReadBytes += 4 - if type != 0 : - field = SISFieldTypes[type]() - field.type = type + if type_ != 0: + field = SISFieldTypes[type_]() + field.type_ = type_ field.initFromFile(fileReader) self.lastReadBytes += field.length + 4 # Field length + length field self.lastReadBytes += fileReader.skipPadding() return field -class SISInfo(SISField) : +class SISInfo(SISField): """ SIS file information """ - def __init__(self) : + def __init__(self): SISField.__init__(self) self.fin = None self.fileHeader = SISFileHeader() - def parse(self, filename) : + def parse(self, filename): """parse""" fin = open(filename, 'rb') fileReader = SISFileReader(fin) self.parseHeader(fileReader) self.parseSISFields(fileReader) - def parseHeader(self, fileReader) : + def parseHeader(self, fileReader): """parse Holder""" self.fileHeader.uid1 = fileReader.readBytesAsUint(4) self.fileHeader.uid2 = fileReader.readBytesAsUint(4) self.fileHeader.uid3 = fileReader.readBytesAsUint(4) self.fileHeader.uidChecksum = fileReader.readBytesAsUint(4) - def parseSISFields(self, fileReader) : + def parseSISFields(self, fileReader): """parse SIS Fileds""" parser = SISFieldParser() - while not fileReader.isEof() : + while not fileReader.isEof(): self.subFields.append(parser.parseField(fileReader)) -class Handler : +class Handler: """ A handler class """ - def __init__(self) : + def __init__(self): self.files = [] self.fileDatas = [] self.signatureCertificateChains = [] - def handleField(self, field, _) : + def handleField(self, field, _): """handle Field""" - if field.type == FileDescriptionField : + if field.type_ == FileDescriptionField: self.files.append(field) - elif field.type == FileDataField : + elif field.type_ == FileDataField: self.fileDatas.append(field) - elif field.type == SignatureCertificateChainField : + elif field.type_ == SignatureCertificateChainField : self.signatureCertificateChains.append(field) - def execute(self, options) : + def execute(self, options): """execute""" - for f_file in self.files : - if options.info : + for f_file in self.files: + if options.info: buf = " " + f_file.findField(StringField)[0].readableStr() caps = f_file.findField(CapabilitiesField)[0] - if caps : + if caps: buf += " [" + " ".join(f_file.findField(CapabilitiesField)[0].readableCaps) + "]" print buf - if options.extract : + if options.extract: parts = f_file.findField(StringField)[0].readableStr().split("\\") - if len(parts[len(parts) - 1]) > 0 : + if len(parts[len(parts) - 1]) > 0: path = os.path.abspath(options.extract) path += os.sep + os.sep.join(parts[1: - 1]) - if not os.path.exists(path) : + if not os.path.exists(path): os.makedirs(path) newFile = file(path + os.sep + parts[len(parts) - 1], "wb") newFile.write(self.fileDatas[f_file.fileIndex].findField(CompressedField)[0].data) newFile.close() - for sig in self.signatureCertificateChains : + for sig in self.signatureCertificateChains: if options.certificate: buf = sig.findField(CertificateChainField)[0].subFields[0].data print "Certificate chain:" i_num = 1 - while len(buf) > 0 : + while len(buf) > 0: print " Certificate " + str(i_num) + ":" i_num += 1 decoded = decoder.decode(buf) @@ -1104,24 +1111,24 @@ print " " + "\n ".join(readableStr.split('\n')) buf = decoded[1] -class ContentPrinter : +class ContentPrinter: """ A handler class which prints the field contents """ - def __init__(self) : + def __init__(self): pass - def handleField(self, field, depth) : + def handleField(self, field, depth): """handle Field""" buf = "" - for _ in range(depth) : + for _ in range(depth): buf += " " - buf += FieldNames[field.type] + " " - if len(field.readableStr()) > 0 : + buf += FieldNames[field.type_] + " " + if len(field.readableStr()) > 0: buf += field.readableStr() print buf -class IADHandler : +class IADHandler: """ IAD handler class """ - def __init__(self) : + def __init__(self): self.packageVersion = (0, 0, 0) self.packageUid = 0 self.vendorName = "" @@ -1132,26 +1139,29 @@ self.packageDependencies = [] self.installType = 0 self.installFlags = 0 + self.packageVersionField = None + self.packageUidField = None + self.vendorNameField = None - def handleDependency(self, field) : + def handleDependency(self, field): """handle dependancy""" dep = [0, - 1, - 1, - 1, - 1, - 1, - 1] dep[0] = field.subFields[0].uid - if field.subFields[1] and field.subFields[1].type == VersionRangeField : + if field.subFields[1] and field.subFields[1].type_ == VersionRangeField: res = field.subFields[1] - if res.fromVersion != None : + if res.fromVersion != None: dep[1] = res.fromVersion.version[0] dep[2] = res.fromVersion.version[1] dep[3] = res.fromVersion.version[2] - if res.toVersion != None : + if res.toVersion != None: dep[4] = res.toVersion.version[0] dep[5] = res.toVersion.version[1] dep[6] = res.toVersion.version[2] return dep - def handleField(self, field, _) : + def handleField(self, field, _): """handle Field""" - if field.type == InfoField : + if field.type_ == InfoField: self.packageVersion = field.subFields[4].version self.packageVersionField = field.subFields[4] self.packageUid = field.subFields[0].uid @@ -1160,19 +1170,19 @@ self.vendorNameField = field.subFields[1] self.installType = field.installType self.installFlags = field.installFlags - for name in field.subFields[2].subFields : + for name in field.subFields[2].subFields: self.packageNames.append(name.data) - elif field.type == LanguageField : + elif field.type_ == LanguageField: self.languages.append(field.language) - elif field.type == PrerequisitiesField : - for f_field in field.subFields[0].subFields : + elif field.type_ == PrerequisitiesField: + for f_field in field.subFields[0].subFields: dependency = self.handleDependency(f_field) self.platformDependencies.append(dependency) - for f_field in field.subFields[1].subFields : + for f_field in field.subFields[1].subFields: dependency = self.handleDependency(f_field) self.packageDependencies.append(dependency) - def getInfo (self, fileName) : + def getInfo (self, fileName): """get Info""" sisInfo = SISInfo() sisInfo.parse(fileName) @@ -1187,11 +1197,11 @@ + "" + repr(handler.packageVersion[2]) + "" \ + "\n" \ + " " + InstallTypes[self.installType] + "\n" - for num, name in enumerate(handler.packageNames) : + for num, name in enumerate(handler.packageNames): info += " " + name + "\n" - for language in handler.languages : + for language in handler.languages: info += " " + repr(language) + "\n" - for platDep in handler.platformDependencies : + for platDep in handler.platformDependencies: info += " " + hex(platDep[0]) + "\n" info += " " \ + "" + repr(platDep[1]) + "" \ @@ -1203,7 +1213,7 @@ # info += "" + repr(platDep[6]) + "" info += "\n" \ + " \n" - for packageDep in handler.packageDependencies : + for packageDep in handler.packageDependencies: info += " " + hex(packageDep[0]) + "\n" info += " " \ + "" + repr(packageDep[1]) + "" \ @@ -1218,6 +1228,6 @@ info += "\n" return info -if __name__ == "__main__" : +if __name__ == "__main__": _handler = IADHandler() print (_handler.getInfo (sys.argv[1]))