| ## @file |
| # Parse FV image |
| # |
| # Copyright (c) 2008 - 2010, Intel Corporation. All rights reserved.<BR> |
| # This program and the accompanying materials |
| # are licensed and made available under the terms and conditions of the BSD License |
| # which accompanies this distribution. The full text of the license may be found at |
| # http://opensource.org/licenses/bsd-license.php |
| # |
| # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. |
| # |
| |
| ## Import Modules |
| # |
| import os |
| import re |
| import sys |
| import uuid |
| import struct |
| import codecs |
| import copy |
| |
| from UserDict import IterableUserDict |
| from cStringIO import StringIO |
| from array import array |
| |
| from CommonDataClass import * |
| from Common.Misc import sdict, GuidStructureStringToGuidString |
| |
| import Common.EdkLogger as EdkLogger |
| |
| import EotGlobalData |
| |
| # Global definiton |
| gFfsPrintTitle = "%-36s %-21s %8s %8s %8s %-4s %-36s" % ("GUID", "TYPE", "OFFSET", "SIZE", "FREE", "ALIGN", "NAME") |
| gFfsPrintFormat = "%36s %-21s %8X %8X %8X %4s %-36s" |
| gGuidStringFormat = "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X" |
| gPeiAprioriFileNameGuid = '1b45cc0a-156a-428a-af62-49864da0e6e6' |
| gAprioriGuid = 'fc510ee7-ffdc-11d4-bd41-0080c73c8881' |
| gIndention = -4 |
| |
| ## Image() class |
| # |
| # A class for Image |
| # |
| class Image(array): |
| _HEADER_ = struct.Struct("") |
| _HEADER_SIZE_ = _HEADER_.size |
| |
| def __new__(cls, *args, **kwargs): |
| return array.__new__(cls, 'B') |
| |
| def __init__(m, ID=None): |
| if ID == None: |
| m._ID_ = str(uuid.uuid1()).upper() |
| else: |
| m._ID_ = ID |
| m._BUF_ = None |
| m._LEN_ = None |
| m._OFF_ = None |
| |
| m._SubImages = sdict() # {offset: Image()} |
| |
| array.__init__(m, 'B') |
| |
| def __repr__(m): |
| return m._ID_ |
| |
| def __len__(m): |
| Len = array.__len__(m) |
| for Offset in m._SubImages: |
| Len += len(m._SubImages[Offset]) |
| return Len |
| |
| def _Unpack(m): |
| m.extend(m._BUF_[m._OFF_ : m._OFF_ + m._LEN_]) |
| return len(m) |
| |
| def _Pack(m, PadByte=0xFF): |
| raise NotImplementedError |
| |
| def frombuffer(m, Buffer, Offset=0, Size=None): |
| m._BUF_ = Buffer |
| m._OFF_ = Offset |
| # we may need the Size information in advance if it's given |
| m._LEN_ = Size |
| m._LEN_ = m._Unpack() |
| |
| def empty(m): |
| del m[0:] |
| |
| def GetField(m, FieldStruct, Offset=0): |
| return FieldStruct.unpack_from(m, Offset) |
| |
| def SetField(m, FieldStruct, Offset, *args): |
| # check if there's enough space |
| Size = FieldStruct.size |
| if Size > len(m): |
| m.extend([0] * (Size - len(m))) |
| FieldStruct.pack_into(m, Offset, *args) |
| |
| def _SetData(m, Data): |
| if len(m) < m._HEADER_SIZE_: |
| m.extend([0] * (m._HEADER_SIZE_ - len(m))) |
| else: |
| del m[m._HEADER_SIZE_:] |
| m.extend(Data) |
| |
| def _GetData(m): |
| if len(m) > m._HEADER_SIZE_: |
| return m[m._HEADER_SIZE_:] |
| return None |
| |
| Data = property(_GetData, _SetData) |
| |
| ## FirmwareVolume() class |
| # |
| # A class for Firmware Volume |
| # |
| class FirmwareVolume(Image): |
| # Read FvLength, Attributes, HeaderLength, Checksum |
| _HEADER_ = struct.Struct("16x 1I2H8B 1Q 4x 1I 1H 1H") |
| _HEADER_SIZE_ = _HEADER_.size |
| |
| _FfsGuid = "8C8CE578-8A3D-4F1C-9935-896185C32DD3" |
| |
| _GUID_ = struct.Struct("16x 1I2H8B") |
| _LENGTH_ = struct.Struct("16x 16x 1Q") |
| _SIG_ = struct.Struct("16x 16x 8x 1I") |
| _ATTR_ = struct.Struct("16x 16x 8x 4x 1I") |
| _HLEN_ = struct.Struct("16x 16x 8x 4x 4x 1H") |
| _CHECKSUM_ = struct.Struct("16x 16x 8x 4x 4x 2x 1H") |
| |
| def __init__(self, Name=''): |
| Image.__init__(self) |
| self.Name = Name |
| self.FfsDict = sdict() |
| self.OrderedFfsDict = sdict() |
| self.UnDispatchedFfsDict = sdict() |
| self.NoDepexFfsDict = sdict() |
| self.ProtocolList = sdict() |
| |
| def CheckArchProtocol(self): |
| for Item in EotGlobalData.gArchProtocolGuids: |
| if Item.lower() not in EotGlobalData.gProtocolList: |
| |
| return False |
| |
| return True |
| |
| def ParseDepex(self, Depex, Type): |
| List = None |
| if Type == 'Ppi': |
| List = EotGlobalData.gPpiList |
| if Type == 'Protocol': |
| List = EotGlobalData.gProtocolList |
| DepexStack = [] |
| DepexList = [] |
| DepexString = '' |
| FileDepex = None |
| CouldBeLoaded = True |
| for Index in range(0, len(Depex.Expression)): |
| Item = Depex.Expression[Index] |
| if Item == 0x00: |
| Index = Index + 1 |
| Guid = gGuidStringFormat % Depex.Expression[Index] |
| if Guid in self.OrderedFfsDict and Depex.Expression[Index + 1] == 0x08: |
| return (True, 'BEFORE %s' % Guid, [Guid, 'BEFORE']) |
| elif Item == 0x01: |
| Index = Index + 1 |
| Guid = gGuidStringFormat % Depex.Expression[Index] |
| if Guid in self.OrderedFfsDict and Depex.Expression[Index + 1] == 0x08: |
| return (True, 'AFTER %s' % Guid, [Guid, 'AFTER']) |
| elif Item == 0x02: |
| Index = Index + 1 |
| Guid = gGuidStringFormat % Depex.Expression[Index] |
| if Guid.lower() in List: |
| DepexStack.append(True) |
| DepexList.append(Guid) |
| else: |
| DepexStack.append(False) |
| DepexList.append(Guid) |
| continue |
| elif Item == 0x03 or Item == 0x04: |
| DepexStack.append(eval(str(DepexStack.pop()) + ' ' + Depex._OPCODE_STRING_[Item].lower() + ' ' + str(DepexStack.pop()))) |
| DepexList.append(str(DepexList.pop()) + ' ' + Depex._OPCODE_STRING_[Item].upper() + ' ' + str(DepexList.pop())) |
| elif Item == 0x05: |
| DepexStack.append(eval(Depex._OPCODE_STRING_[Item].lower() + ' ' + str(DepexStack.pop()))) |
| DepexList.append(Depex._OPCODE_STRING_[Item].lower() + ' ' + str(DepexList.pop())) |
| elif Item == 0x06: |
| DepexStack.append(True) |
| DepexList.append('TRUE') |
| DepexString = DepexString + 'TRUE' + ' ' |
| elif Item == 0x07: |
| DepexStack.append(False) |
| DepexList.append('False') |
| DepexString = DepexString + 'FALSE' + ' ' |
| elif Item == 0x08: |
| if Index != len(Depex.Expression) - 1: |
| CouldBeLoaded = False |
| else: |
| CouldBeLoaded = DepexStack.pop() |
| else: |
| CouldBeLoaded = False |
| if DepexList != []: |
| DepexString = DepexList[0].strip() |
| return (CouldBeLoaded, DepexString, FileDepex) |
| |
| def Dispatch(self, Db = None): |
| if Db == None: |
| return False |
| self.UnDispatchedFfsDict = copy.copy(self.FfsDict) |
| # Find PeiCore, DexCore, PeiPriori, DxePriori first |
| FfsSecCoreGuid = None |
| FfsPeiCoreGuid = None |
| FfsDxeCoreGuid = None |
| FfsPeiPrioriGuid = None |
| FfsDxePrioriGuid = None |
| for FfsID in self.UnDispatchedFfsDict: |
| Ffs = self.UnDispatchedFfsDict[FfsID] |
| if Ffs.Type == 0x03: |
| FfsSecCoreGuid = FfsID |
| continue |
| if Ffs.Type == 0x04: |
| FfsPeiCoreGuid = FfsID |
| continue |
| if Ffs.Type == 0x05: |
| FfsDxeCoreGuid = FfsID |
| continue |
| if Ffs.Guid.lower() == gPeiAprioriFileNameGuid: |
| FfsPeiPrioriGuid = FfsID |
| continue |
| if Ffs.Guid.lower() == gAprioriGuid: |
| FfsDxePrioriGuid = FfsID |
| continue |
| |
| # Parse SEC_CORE first |
| if FfsSecCoreGuid != None: |
| self.OrderedFfsDict[FfsSecCoreGuid] = self.UnDispatchedFfsDict.pop(FfsSecCoreGuid) |
| self.LoadPpi(Db, FfsSecCoreGuid) |
| |
| # Parse PEI first |
| if FfsPeiCoreGuid != None: |
| self.OrderedFfsDict[FfsPeiCoreGuid] = self.UnDispatchedFfsDict.pop(FfsPeiCoreGuid) |
| self.LoadPpi(Db, FfsPeiCoreGuid) |
| if FfsPeiPrioriGuid != None: |
| # Load PEIM described in priori file |
| FfsPeiPriori = self.UnDispatchedFfsDict.pop(FfsPeiPrioriGuid) |
| if len(FfsPeiPriori.Sections) == 1: |
| Section = FfsPeiPriori.Sections.popitem()[1] |
| if Section.Type == 0x19: |
| GuidStruct = struct.Struct('1I2H8B') |
| Start = 4 |
| while len(Section) > Start: |
| Guid = GuidStruct.unpack_from(Section[Start : Start + 16]) |
| GuidString = gGuidStringFormat % Guid |
| Start = Start + 16 |
| if GuidString in self.UnDispatchedFfsDict: |
| self.OrderedFfsDict[GuidString] = self.UnDispatchedFfsDict.pop(GuidString) |
| self.LoadPpi(Db, GuidString) |
| |
| self.DisPatchPei(Db) |
| |
| # Parse DXE then |
| if FfsDxeCoreGuid != None: |
| self.OrderedFfsDict[FfsDxeCoreGuid] = self.UnDispatchedFfsDict.pop(FfsDxeCoreGuid) |
| self.LoadProtocol(Db, FfsDxeCoreGuid) |
| if FfsDxePrioriGuid != None: |
| # Load PEIM described in priori file |
| FfsDxePriori = self.UnDispatchedFfsDict.pop(FfsDxePrioriGuid) |
| if len(FfsDxePriori.Sections) == 1: |
| Section = FfsDxePriori.Sections.popitem()[1] |
| if Section.Type == 0x19: |
| GuidStruct = struct.Struct('1I2H8B') |
| Start = 4 |
| while len(Section) > Start: |
| Guid = GuidStruct.unpack_from(Section[Start : Start + 16]) |
| GuidString = gGuidStringFormat % Guid |
| Start = Start + 16 |
| if GuidString in self.UnDispatchedFfsDict: |
| self.OrderedFfsDict[GuidString] = self.UnDispatchedFfsDict.pop(GuidString) |
| self.LoadProtocol(Db, GuidString) |
| |
| self.DisPatchDxe(Db) |
| |
| def DisPatchNoDepexFfs(self, Db): |
| # Last Load Drivers without Depex |
| for FfsID in self.NoDepexFfsDict: |
| NewFfs = self.NoDepexFfsDict.pop(FfsID) |
| self.OrderedFfsDict[FfsID] = NewFfs |
| self.LoadProtocol(Db, FfsID) |
| |
| return True |
| |
| def LoadCallbackProtocol(self): |
| IsLoad = True |
| for Protocol in self.ProtocolList: |
| for Callback in self.ProtocolList[Protocol][1]: |
| if Callback[0] not in self.OrderedFfsDict.keys(): |
| IsLoad = False |
| continue |
| if IsLoad: |
| EotGlobalData.gProtocolList[Protocol.lower()] = self.ProtocolList[Protocol][0] |
| self.ProtocolList.pop(Protocol) |
| |
| def LoadProtocol(self, Db, ModuleGuid): |
| SqlCommand = """select GuidValue from Report |
| where SourceFileFullPath in |
| (select Value1 from Inf where BelongsToFile = |
| (select BelongsToFile from Inf |
| where Value1 = 'FILE_GUID' and Value2 like '%s' and Model = %s) |
| and Model = %s) |
| and ItemType = 'Protocol' and ItemMode = 'Produced'""" \ |
| % (ModuleGuid, 5001, 3007) |
| RecordSet = Db.TblReport.Exec(SqlCommand) |
| for Record in RecordSet: |
| SqlCommand = """select Value2 from Inf where BelongsToFile = |
| (select DISTINCT BelongsToFile from Inf |
| where Value1 = |
| (select SourceFileFullPath from Report |
| where GuidValue like '%s' and ItemMode = 'Callback')) |
| and Value1 = 'FILE_GUID'""" % Record[0] |
| CallBackSet = Db.TblReport.Exec(SqlCommand) |
| if CallBackSet != []: |
| EotGlobalData.gProtocolList[Record[0].lower()] = ModuleGuid |
| else: |
| EotGlobalData.gProtocolList[Record[0].lower()] = ModuleGuid |
| |
| def LoadPpi(self, Db, ModuleGuid): |
| SqlCommand = """select GuidValue from Report |
| where SourceFileFullPath in |
| (select Value1 from Inf where BelongsToFile = |
| (select BelongsToFile from Inf |
| where Value1 = 'FILE_GUID' and Value2 like '%s' and Model = %s) |
| and Model = %s) |
| and ItemType = 'Ppi' and ItemMode = 'Produced'""" \ |
| % (ModuleGuid, 5001, 3007) |
| RecordSet = Db.TblReport.Exec(SqlCommand) |
| for Record in RecordSet: |
| EotGlobalData.gPpiList[Record[0].lower()] = ModuleGuid |
| |
| def DisPatchDxe(self, Db): |
| IsInstalled = False |
| ScheduleList = sdict() |
| for FfsID in self.UnDispatchedFfsDict: |
| CouldBeLoaded = False |
| DepexString = '' |
| FileDepex = None |
| Ffs = self.UnDispatchedFfsDict[FfsID] |
| if Ffs.Type == 0x07: |
| # Get Depex |
| IsFoundDepex = False |
| for Section in Ffs.Sections.values(): |
| # Find Depex |
| if Section.Type == 0x13: |
| IsFoundDepex = True |
| CouldBeLoaded, DepexString, FileDepex = self.ParseDepex(Section._SubImages[4], 'Protocol') |
| break |
| if Section.Type == 0x01: |
| CompressSections = Section._SubImages[4] |
| for CompressSection in CompressSections.Sections: |
| if CompressSection.Type == 0x13: |
| IsFoundDepex = True |
| CouldBeLoaded, DepexString, FileDepex = self.ParseDepex(CompressSection._SubImages[4], 'Protocol') |
| break |
| if CompressSection.Type == 0x02: |
| NewSections = CompressSection._SubImages[4] |
| for NewSection in NewSections.Sections: |
| if NewSection.Type == 0x13: |
| IsFoundDepex = True |
| CouldBeLoaded, DepexString, FileDepex = self.ParseDepex(NewSection._SubImages[4], 'Protocol') |
| break |
| |
| # Not find Depex |
| if not IsFoundDepex: |
| CouldBeLoaded = self.CheckArchProtocol() |
| DepexString = '' |
| FileDepex = None |
| |
| # Append New Ffs |
| if CouldBeLoaded: |
| IsInstalled = True |
| NewFfs = self.UnDispatchedFfsDict.pop(FfsID) |
| NewFfs.Depex = DepexString |
| if FileDepex != None: |
| ScheduleList.insert.insert(FileDepex[1], FfsID, NewFfs, FileDepex[0]) |
| else: |
| ScheduleList[FfsID] = NewFfs |
| else: |
| self.UnDispatchedFfsDict[FfsID].Depex = DepexString |
| |
| for FfsID in ScheduleList: |
| NewFfs = ScheduleList.pop(FfsID) |
| FfsName = 'UnKnown' |
| self.OrderedFfsDict[FfsID] = NewFfs |
| self.LoadProtocol(Db, FfsID) |
| |
| SqlCommand = """select Value2 from Inf |
| where BelongsToFile = (select BelongsToFile from Inf where Value1 = 'FILE_GUID' and lower(Value2) = lower('%s') and Model = %s) |
| and Model = %s and Value1='BASE_NAME'""" % (FfsID, 5001, 5001) |
| RecordSet = Db.TblReport.Exec(SqlCommand) |
| if RecordSet != []: |
| FfsName = RecordSet[0][0] |
| |
| if IsInstalled: |
| self.DisPatchDxe(Db) |
| |
| def DisPatchPei(self, Db): |
| IsInstalled = False |
| for FfsID in self.UnDispatchedFfsDict: |
| CouldBeLoaded = True |
| DepexString = '' |
| FileDepex = None |
| Ffs = self.UnDispatchedFfsDict[FfsID] |
| if Ffs.Type == 0x06 or Ffs.Type == 0x08: |
| # Get Depex |
| for Section in Ffs.Sections.values(): |
| if Section.Type == 0x1B: |
| CouldBeLoaded, DepexString, FileDepex = self.ParseDepex(Section._SubImages[4], 'Ppi') |
| break |
| |
| if Section.Type == 0x01: |
| CompressSections = Section._SubImages[4] |
| for CompressSection in CompressSections.Sections: |
| if CompressSection.Type == 0x1B: |
| CouldBeLoaded, DepexString, FileDepex = self.ParseDepex(CompressSection._SubImages[4], 'Ppi') |
| break |
| if CompressSection.Type == 0x02: |
| NewSections = CompressSection._SubImages[4] |
| for NewSection in NewSections.Sections: |
| if NewSection.Type == 0x1B: |
| CouldBeLoaded, DepexString, FileDepex = self.ParseDepex(NewSection._SubImages[4], 'Ppi') |
| break |
| |
| # Append New Ffs |
| if CouldBeLoaded: |
| IsInstalled = True |
| NewFfs = self.UnDispatchedFfsDict.pop(FfsID) |
| NewFfs.Depex = DepexString |
| self.OrderedFfsDict[FfsID] = NewFfs |
| self.LoadPpi(Db, FfsID) |
| else: |
| self.UnDispatchedFfsDict[FfsID].Depex = DepexString |
| |
| if IsInstalled: |
| self.DisPatchPei(Db) |
| |
| |
| def __str__(self): |
| global gIndention |
| gIndention += 4 |
| FvInfo = '\n' + ' ' * gIndention |
| FvInfo += "[FV:%s] file_system=%s size=%x checksum=%s\n" % (self.Name, self.FileSystemGuid, self.Size, self.Checksum) |
| FfsInfo = "\n".join([str(self.FfsDict[FfsId]) for FfsId in self.FfsDict]) |
| gIndention -= 4 |
| return FvInfo + FfsInfo |
| |
| def _Unpack(self): |
| Size = self._LENGTH_.unpack_from(self._BUF_, self._OFF_)[0] |
| self.empty() |
| self.extend(self._BUF_[self._OFF_:self._OFF_+Size]) |
| |
| # traverse the FFS |
| EndOfFv = Size |
| FfsStartAddress = self.HeaderSize |
| LastFfsObj = None |
| while FfsStartAddress < EndOfFv: |
| FfsObj = Ffs() |
| FfsObj.frombuffer(self, FfsStartAddress) |
| FfsId = repr(FfsObj) |
| if ((self.Attributes & 0x00000800) != 0 and len(FfsObj) == 0xFFFFFF) \ |
| or ((self.Attributes & 0x00000800) == 0 and len(FfsObj) == 0): |
| if LastFfsObj != None: |
| LastFfsObj.FreeSpace = EndOfFv - LastFfsObj._OFF_ - len(LastFfsObj) |
| else: |
| if FfsId in self.FfsDict: |
| EdkLogger.error("FV", 0, "Duplicate GUID in FFS", |
| ExtraData="\t%s @ %s\n\t%s @ %s" \ |
| % (FfsObj.Guid, FfsObj.Offset, |
| self.FfsDict[FfsId].Guid, self.FfsDict[FfsId].Offset)) |
| self.FfsDict[FfsId] = FfsObj |
| if LastFfsObj != None: |
| LastFfsObj.FreeSpace = FfsStartAddress - LastFfsObj._OFF_ - len(LastFfsObj) |
| |
| FfsStartAddress += len(FfsObj) |
| # |
| # align to next 8-byte aligned address: A = (A + 8 - 1) & (~(8 - 1)) |
| # The next FFS must be at the latest next 8-byte aligned address |
| # |
| FfsStartAddress = (FfsStartAddress + 7) & (~7) |
| LastFfsObj = FfsObj |
| |
| def _GetAttributes(self): |
| return self.GetField(self._ATTR_, 0)[0] |
| |
| def _GetSize(self): |
| return self.GetField(self._LENGTH_, 0)[0] |
| |
| def _GetChecksum(self): |
| return self.GetField(self._CHECKSUM_, 0)[0] |
| |
| def _GetHeaderLength(self): |
| return self.GetField(self._HLEN_, 0)[0] |
| |
| def _GetFileSystemGuid(self): |
| return gGuidStringFormat % self.GetField(self._GUID_, 0) |
| |
| Attributes = property(_GetAttributes) |
| Size = property(_GetSize) |
| Checksum = property(_GetChecksum) |
| HeaderSize = property(_GetHeaderLength) |
| FileSystemGuid = property(_GetFileSystemGuid) |
| |
| ## CompressedImage() class |
| # |
| # A class for Compressed Image |
| # |
| class CompressedImage(Image): |
| # UncompressedLength = 4-byte |
| # CompressionType = 1-byte |
| _HEADER_ = struct.Struct("1I 1B") |
| _HEADER_SIZE_ = _HEADER_.size |
| |
| _ORIG_SIZE_ = struct.Struct("1I") |
| _CMPRS_TYPE_ = struct.Struct("4x 1B") |
| |
| def __init__(m, CompressedData=None, CompressionType=None, UncompressedLength=None): |
| Image.__init__(m) |
| if UncompressedLength != None: |
| m.UncompressedLength = UncompressedLength |
| if CompressionType != None: |
| m.CompressionType = CompressionType |
| if CompressedData != None: |
| m.Data = CompressedData |
| |
| def __str__(m): |
| global gIndention |
| S = "algorithm=%s uncompressed=%x" % (m.CompressionType, m.UncompressedLength) |
| for Sec in m.Sections: |
| S += '\n' + str(Sec) |
| |
| return S |
| |
| def _SetOriginalSize(m, Size): |
| m.SetField(m._ORIG_SIZE_, 0, Size) |
| |
| def _GetOriginalSize(m): |
| return m.GetField(m._ORIG_SIZE_)[0] |
| |
| def _SetCompressionType(m, Type): |
| m.SetField(m._CMPRS_TYPE_, 0, Type) |
| |
| def _GetCompressionType(m): |
| return m.GetField(m._CMPRS_TYPE_)[0] |
| |
| def _GetSections(m): |
| try: |
| import EfiCompressor |
| TmpData = EfiCompressor.FrameworkDecompress( |
| m[m._HEADER_SIZE_:], |
| len(m) - m._HEADER_SIZE_ |
| ) |
| DecData = array('B') |
| DecData.fromstring(TmpData) |
| except: |
| import EfiCompressor |
| TmpData = EfiCompressor.UefiDecompress( |
| m[m._HEADER_SIZE_:], |
| len(m) - m._HEADER_SIZE_ |
| ) |
| DecData = array('B') |
| DecData.fromstring(TmpData) |
| |
| SectionList = [] |
| Offset = 0 |
| while Offset < len(DecData): |
| Sec = Section() |
| try: |
| Sec.frombuffer(DecData, Offset) |
| Offset += Sec.Size |
| # the section is aligned to 4-byte boundary |
| except: |
| break |
| SectionList.append(Sec) |
| return SectionList |
| |
| UncompressedLength = property(_GetOriginalSize, _SetOriginalSize) |
| CompressionType = property(_GetCompressionType, _SetCompressionType) |
| Sections = property(_GetSections) |
| |
| ## GuidDefinedImage() class |
| # |
| # A class for GUID Defined Image |
| # |
| class GuidDefinedImage(Image): |
| _HEADER_ = struct.Struct("1I2H8B 1H 1H") |
| _HEADER_SIZE_ = _HEADER_.size |
| |
| _GUID_ = struct.Struct("1I2H8B") |
| _DATA_OFFSET_ = struct.Struct("16x 1H") |
| _ATTR_ = struct.Struct("18x 1H") |
| |
| CRC32_GUID = "FC1BCDB0-7D31-49AA-936A-A4600D9DD083" |
| TIANO_COMPRESS_GUID = 'A31280AD-481E-41B6-95E8-127F4C984779' |
| LZMA_COMPRESS_GUID = 'EE4E5898-3914-4259-9D6E-DC7BD79403CF' |
| |
| def __init__(m, SectionDefinitionGuid=None, DataOffset=None, Attributes=None, Data=None): |
| Image.__init__(m) |
| if SectionDefinitionGuid != None: |
| m.SectionDefinitionGuid = SectionDefinitionGuid |
| if DataOffset != None: |
| m.DataOffset = DataOffset |
| if Attributes != None: |
| m.Attributes = Attributes |
| if Data != None: |
| m.Data = Data |
| |
| def __str__(m): |
| S = "guid=%s" % (gGuidStringFormat % m.SectionDefinitionGuid) |
| for Sec in m.Sections: |
| S += "\n" + str(Sec) |
| return S |
| |
| def _Unpack(m): |
| # keep header in this Image object |
| m.empty() |
| m.extend(m._BUF_[m._OFF_ : m._OFF_ + m._LEN_]) |
| return len(m) |
| |
| def _SetAttribute(m, Attribute): |
| m.SetField(m._ATTR_, 0, Attribute) |
| |
| def _GetAttribute(m): |
| return m.GetField(m._ATTR_)[0] |
| |
| def _SetGuid(m, Guid): |
| m.SetField(m._GUID_, 0, Guid) |
| |
| def _GetGuid(m): |
| return m.GetField(m._GUID_) |
| |
| def _SetDataOffset(m, Offset): |
| m.SetField(m._DATA_OFFSET_, 0, Offset) |
| |
| def _GetDataOffset(m): |
| return m.GetField(m._DATA_OFFSET_)[0] |
| |
| def _GetSections(m): |
| SectionList = [] |
| Guid = gGuidStringFormat % m.SectionDefinitionGuid |
| if Guid == m.CRC32_GUID: |
| # skip the CRC32 value, we don't do CRC32 verification here |
| Offset = m.DataOffset - 4 |
| while Offset < len(m): |
| Sec = Section() |
| try: |
| Sec.frombuffer(m, Offset) |
| Offset += Sec.Size |
| # the section is aligned to 4-byte boundary |
| Offset = (Offset + 3) & (~3) |
| except: |
| break |
| SectionList.append(Sec) |
| elif Guid == m.TIANO_COMPRESS_GUID: |
| try: |
| import EfiCompressor |
| # skip the header |
| Offset = m.DataOffset - 4 |
| TmpData = EfiCompressor.FrameworkDecompress(m[Offset:], len(m)-Offset) |
| DecData = array('B') |
| DecData.fromstring(TmpData) |
| Offset = 0 |
| while Offset < len(DecData): |
| Sec = Section() |
| try: |
| Sec.frombuffer(DecData, Offset) |
| Offset += Sec.Size |
| # the section is aligned to 4-byte boundary |
| Offset = (Offset + 3) & (~3) |
| except: |
| break |
| SectionList.append(Sec) |
| except: |
| pass |
| elif Guid == m.LZMA_COMPRESS_GUID: |
| try: |
| import LzmaCompressor |
| # skip the header |
| Offset = m.DataOffset - 4 |
| TmpData = LzmaCompressor.LzmaDecompress(m[Offset:], len(m)-Offset) |
| DecData = array('B') |
| DecData.fromstring(TmpData) |
| Offset = 0 |
| while Offset < len(DecData): |
| Sec = Section() |
| try: |
| Sec.frombuffer(DecData, Offset) |
| Offset += Sec.Size |
| # the section is aligned to 4-byte boundary |
| Offset = (Offset + 3) & (~3) |
| except: |
| break |
| SectionList.append(Sec) |
| except: |
| pass |
| |
| return SectionList |
| |
| Attributes = property(_GetAttribute, _SetAttribute) |
| SectionDefinitionGuid = property(_GetGuid, _SetGuid) |
| DataOffset = property(_GetDataOffset, _SetDataOffset) |
| Sections = property(_GetSections) |
| |
| ## Depex() class |
| # |
| # A class for Depex |
| # |
| class Depex(Image): |
| _HEADER_ = struct.Struct("") |
| _HEADER_SIZE_ = 0 |
| |
| _GUID_ = struct.Struct("1I2H8B") |
| _OPCODE_ = struct.Struct("1B") |
| |
| _OPCODE_STRING_ = { |
| 0x00 : "BEFORE", |
| 0x01 : "AFTER", |
| 0x02 : "PUSH", |
| 0x03 : "AND", |
| 0x04 : "OR", |
| 0x05 : "NOT", |
| 0x06 : "TRUE", |
| 0x07 : "FALSE", |
| 0x08 : "END", |
| 0x09 : "SOR" |
| } |
| |
| _NEXT_ = { |
| -1 : _OPCODE_, # first one in depex must be an opcdoe |
| 0x00 : _GUID_, #"BEFORE", |
| 0x01 : _GUID_, #"AFTER", |
| 0x02 : _GUID_, #"PUSH", |
| 0x03 : _OPCODE_, #"AND", |
| 0x04 : _OPCODE_, #"OR", |
| 0x05 : _OPCODE_, #"NOT", |
| 0x06 : _OPCODE_, #"TRUE", |
| 0x07 : _OPCODE_, #"FALSE", |
| 0x08 : None, #"END", |
| 0x09 : _OPCODE_, #"SOR" |
| } |
| |
| def __init__(m): |
| Image.__init__(m) |
| m._ExprList = [] |
| |
| def __str__(m): |
| global gIndention |
| gIndention += 4 |
| Indention = ' ' * gIndention |
| S = '\n' |
| for T in m.Expression: |
| if T in m._OPCODE_STRING_: |
| S += Indention + m._OPCODE_STRING_[T] |
| if T not in [0x00, 0x01, 0x02]: |
| S += '\n' |
| else: |
| S += ' ' + gGuidStringFormat % T + '\n' |
| gIndention -= 4 |
| return S |
| |
| def _Unpack(m): |
| # keep header in this Image object |
| m.empty() |
| m.extend(m._BUF_[m._OFF_ : m._OFF_ + m._LEN_]) |
| return len(m) |
| |
| def _GetExpression(m): |
| if m._ExprList == []: |
| Offset = 0 |
| CurrentData = m._OPCODE_ |
| while Offset < len(m): |
| Token = CurrentData.unpack_from(m, Offset) |
| Offset += CurrentData.size |
| if len(Token) == 1: |
| Token = Token[0] |
| if Token in m._NEXT_: |
| CurrentData = m._NEXT_[Token] |
| else: |
| CurrentData = m._GUID_ |
| else: |
| CurrentData = m._OPCODE_ |
| m._ExprList.append(Token) |
| if CurrentData == None: |
| break |
| return m._ExprList |
| |
| Expression = property(_GetExpression) |
| |
| ## Ui() class |
| # |
| # A class for Ui |
| # |
| class Ui(Image): |
| _HEADER_ = struct.Struct("") |
| _HEADER_SIZE_ = 0 |
| |
| def __init__(m): |
| Image.__init__(m) |
| |
| def __str__(m): |
| return m.String |
| |
| def _Unpack(m): |
| # keep header in this Image object |
| m.empty() |
| m.extend(m._BUF_[m._OFF_ : m._OFF_ + m._LEN_]) |
| return len(m) |
| |
| def _GetUiString(m): |
| return codecs.utf_16_decode(m[0:-2].tostring())[0] |
| |
| String = property(_GetUiString) |
| |
| ## Section() class |
| # |
| # A class for Section |
| # |
| class Section(Image): |
| _TypeName = { |
| 0x00 : "<unknown>", |
| 0x01 : "COMPRESSION", |
| 0x02 : "GUID_DEFINED", |
| 0x10 : "PE32", |
| 0x11 : "PIC", |
| 0x12 : "TE", |
| 0x13 : "DXE_DEPEX", |
| 0x14 : "VERSION", |
| 0x15 : "USER_INTERFACE", |
| 0x16 : "COMPATIBILITY16", |
| 0x17 : "FIRMWARE_VOLUME_IMAGE", |
| 0x18 : "FREEFORM_SUBTYPE_GUID", |
| 0x19 : "RAW", |
| 0x1B : "PEI_DEPEX" |
| } |
| |
| _SectionSubImages = { |
| 0x01 : CompressedImage, |
| 0x02 : GuidDefinedImage, |
| 0x17 : FirmwareVolume, |
| 0x13 : Depex, |
| 0x1B : Depex, |
| 0x15 : Ui |
| } |
| |
| # Size = 3-byte |
| # Type = 1-byte |
| _HEADER_ = struct.Struct("3B 1B") |
| _HEADER_SIZE_ = _HEADER_.size |
| |
| # SubTypeGuid |
| # _FREE_FORM_SUBTYPE_GUID_HEADER_ = struct.Struct("1I2H8B") |
| |
| _SIZE_ = struct.Struct("3B") |
| _TYPE_ = struct.Struct("3x 1B") |
| |
| def __init__(m, Type=None, Size=None): |
| Image.__init__(m) |
| m._Alignment = 1 |
| if Type != None: |
| m.Type = Type |
| if Size != None: |
| m.Size = Size |
| |
| def __str__(m): |
| global gIndention |
| gIndention += 4 |
| SectionInfo = ' ' * gIndention |
| if m.Type in m._TypeName: |
| SectionInfo += "[SECTION:%s] offset=%x size=%x" % (m._TypeName[m.Type], m._OFF_, m.Size) |
| else: |
| SectionInfo += "[SECTION:%x<unknown>] offset=%x size=%x " % (m.Type, m._OFF_, m.Size) |
| for Offset in m._SubImages: |
| SectionInfo += ", " + str(m._SubImages[Offset]) |
| gIndention -= 4 |
| return SectionInfo |
| |
| def _Unpack(m): |
| m.empty() |
| Type, = m._TYPE_.unpack_from(m._BUF_, m._OFF_) |
| Size1, Size2, Size3 = m._SIZE_.unpack_from(m._BUF_, m._OFF_) |
| Size = Size1 + (Size2 << 8) + (Size3 << 16) |
| |
| if Type not in m._SectionSubImages: |
| # no need to extract sub-image, keep all in this Image object |
| m.extend(m._BUF_[m._OFF_ : m._OFF_ + Size]) |
| else: |
| # keep header in this Image object |
| m.extend(m._BUF_[m._OFF_ : m._OFF_ + m._HEADER_SIZE_]) |
| # |
| # use new Image object to represent payload, which may be another kind |
| # of image such as PE32 |
| # |
| PayloadOffset = m._HEADER_SIZE_ |
| PayloadLen = m.Size - m._HEADER_SIZE_ |
| Payload = m._SectionSubImages[m.Type]() |
| Payload.frombuffer(m._BUF_, m._OFF_ + m._HEADER_SIZE_, PayloadLen) |
| m._SubImages[PayloadOffset] = Payload |
| |
| return Size |
| |
| def _SetSize(m, Size): |
| Size1 = Size & 0xFF |
| Size2 = (Size & 0xFF00) >> 8 |
| Size3 = (Size & 0xFF0000) >> 16 |
| m.SetField(m._SIZE_, 0, Size1, Size2, Size3) |
| |
| def _GetSize(m): |
| Size1, Size2, Size3 = m.GetField(m._SIZE_) |
| return Size1 + (Size2 << 8) + (Size3 << 16) |
| |
| def _SetType(m, Type): |
| m.SetField(m._TYPE_, 0, Type) |
| |
| def _GetType(m): |
| return m.GetField(m._TYPE_)[0] |
| |
| def _GetAlignment(m): |
| return m._Alignment |
| |
| def _SetAlignment(m, Alignment): |
| m._Alignment = Alignment |
| AlignmentMask = Alignment - 1 |
| # section alignment is actually for payload, so we need to add header size |
| PayloadOffset = m._OFF_ + m._HEADER_SIZE_ |
| if (PayloadOffset & (~AlignmentMask)) == 0: |
| return |
| NewOffset = (PayloadOffset + AlignmentMask) & (~AlignmentMask) |
| while (NewOffset - PayloadOffset) < m._HEADER_SIZE_: |
| NewOffset += m._Alignment |
| |
| def tofile(m, f): |
| m.Size = len(m) |
| Image.tofile(m, f) |
| for Offset in m._SubImages: |
| m._SubImages[Offset].tofile(f) |
| |
| Type = property(_GetType, _SetType) |
| Size = property(_GetSize, _SetSize) |
| Alignment = property(_GetAlignment, _SetAlignment) |
| # SubTypeGuid = property(_GetGuid, _SetGuid) |
| |
| ## PadSection() class |
| # |
| # A class for Pad Section |
| # |
| class PadSection(Section): |
| def __init__(m, Size): |
| Section.__init__(m) |
| m.Type = 0x19 |
| m.Size = Size |
| m.Data = [0] * (Size - m._HEADER_SIZE_) |
| |
| ## Ffs() class |
| # |
| # A class for Ffs Section |
| # |
| class Ffs(Image): |
| _FfsFormat = "24B%(payload_size)sB" |
| # skip IntegrityCheck |
| _HEADER_ = struct.Struct("1I2H8B 2x 1B 1B 3B 1B") |
| _HEADER_SIZE_ = _HEADER_.size |
| |
| _NAME_ = struct.Struct("1I2H8B") |
| _INT_CHECK_ = struct.Struct("16x 1H") |
| _TYPE_ = struct.Struct("18x 1B") |
| _ATTR_ = struct.Struct("19x 1B") |
| _SIZE_ = struct.Struct("20x 3B") |
| _STATE_ = struct.Struct("23x 1B") |
| |
| VTF_GUID = "1BA0062E-C779-4582-8566-336AE8F78F09" |
| |
| FFS_ATTRIB_FIXED = 0x04 |
| FFS_ATTRIB_DATA_ALIGNMENT = 0x38 |
| FFS_ATTRIB_CHECKSUM = 0x40 |
| |
| _TypeName = { |
| 0x00 : "<unknown>", |
| 0x01 : "RAW", |
| 0x02 : "FREEFORM", |
| 0x03 : "SECURITY_CORE", |
| 0x04 : "PEI_CORE", |
| 0x05 : "DXE_CORE", |
| 0x06 : "PEIM", |
| 0x07 : "DRIVER", |
| 0x08 : "COMBINED_PEIM_DRIVER", |
| 0x09 : "APPLICATION", |
| 0x0A : "SMM", |
| 0x0B : "FIRMWARE_VOLUME_IMAGE", |
| 0x0C : "COMBINED_SMM_DXE", |
| 0x0D : "SMM_CORE", |
| 0xc0 : "OEM_MIN", |
| 0xdf : "OEM_MAX", |
| 0xe0 : "DEBUG_MIN", |
| 0xef : "DEBUG_MAX", |
| 0xf0 : "FFS_MIN", |
| 0xff : "FFS_MAX", |
| 0xf0 : "FFS_PAD", |
| } |
| |
| def __init__(self): |
| Image.__init__(self) |
| self.FreeSpace = 0 |
| |
| self.Sections = sdict() |
| self.Depex = '' |
| |
| self.__ID__ = None |
| |
| def __str__(self): |
| global gIndention |
| gIndention += 4 |
| Indention = ' ' * gIndention |
| FfsInfo = Indention |
| FfsInfo += "[FFS:%s] offset=%x size=%x guid=%s free_space=%x alignment=%s\n" % \ |
| (Ffs._TypeName[self.Type], self._OFF_, self.Size, self.Guid, self.FreeSpace, self.Alignment) |
| SectionInfo = '\n'.join([str(self.Sections[Offset]) for Offset in self.Sections]) |
| gIndention -= 4 |
| return FfsInfo + SectionInfo + "\n" |
| |
| def __len__(self): |
| return self.Size |
| |
| def __repr__(self): |
| return self.__ID__ |
| |
| def _Unpack(self): |
| Size1, Size2, Size3 = self._SIZE_.unpack_from(self._BUF_, self._OFF_) |
| Size = Size1 + (Size2 << 8) + (Size3 << 16) |
| self.empty() |
| self.extend(self._BUF_[self._OFF_ : self._OFF_ + Size]) |
| |
| # Pad FFS may use the same GUID. We need to avoid it. |
| if self.Type == 0xf0: |
| self.__ID__ = str(uuid.uuid1()).upper() |
| else: |
| self.__ID__ = self.Guid |
| |
| # Traverse the SECTION. RAW and PAD do not have sections |
| if self.Type not in [0xf0, 0x01] and Size > 0 and Size < 0xFFFFFF: |
| EndOfFfs = Size |
| SectionStartAddress = self._HEADER_SIZE_ |
| while SectionStartAddress < EndOfFfs: |
| SectionObj = Section() |
| SectionObj.frombuffer(self, SectionStartAddress) |
| #f = open(repr(SectionObj), 'wb') |
| #SectionObj.Size = 0 |
| #SectionObj.tofile(f) |
| #f.close() |
| self.Sections[SectionStartAddress] = SectionObj |
| SectionStartAddress += len(SectionObj) |
| SectionStartAddress = (SectionStartAddress + 3) & (~3) |
| |
| def Pack(self): |
| pass |
| |
| def SetFreeSpace(self, Size): |
| self.FreeSpace = Size |
| |
| def _GetGuid(self): |
| return gGuidStringFormat % self.Name |
| |
| def _SetName(self, Value): |
| # Guid1, Guid2, Guid3, Guid4, Guid5, Guid6, Guid7, Guid8, Guid9, Guid10, Guid11 |
| self.SetField(self._NAME_, 0, Value) |
| |
| def _GetName(self): |
| # Guid1, Guid2, Guid3, Guid4, Guid5, Guid6, Guid7, Guid8, Guid9, Guid10, Guid11 |
| return self.GetField(self._NAME_) |
| |
| def _SetSize(m, Size): |
| Size1 = Size & 0xFF |
| Size2 = (Size & 0xFF00) >> 8 |
| Size3 = (Size & 0xFF0000) >> 16 |
| m.SetField(m._SIZE_, 0, Size1, Size2, Size3) |
| |
| def _GetSize(m): |
| Size1, Size2, Size3 = m.GetField(m._SIZE_) |
| return Size1 + (Size2 << 8) + (Size3 << 16) |
| |
| def _SetType(m, Type): |
| m.SetField(m._TYPE_, 0, Type) |
| |
| def _GetType(m): |
| return m.GetField(m._TYPE_)[0] |
| |
| def _SetAttributes(self, Value): |
| self.SetField(m._ATTR_, 0, Value) |
| |
| def _GetAttributes(self): |
| return self.GetField(self._ATTR_)[0] |
| |
| def _GetFixed(self): |
| if (self.Attributes & self.FFS_ATTRIB_FIXED) != 0: |
| return True |
| return False |
| |
| def _GetCheckSum(self): |
| if (self.Attributes & self.FFS_ATTRIB_CHECKSUM) != 0: |
| return True |
| return False |
| |
| def _GetAlignment(self): |
| return (self.Attributes & self.FFS_ATTRIB_DATA_ALIGNMENT) >> 3 |
| |
| def _SetState(self, Value): |
| self.SetField(m._STATE_, 0, Value) |
| |
| def _GetState(self): |
| return self.GetField(m._STATE_)[0] |
| |
| Name = property(_GetName, _SetName) |
| Guid = property(_GetGuid) |
| Type = property(_GetType, _SetType) |
| Size = property(_GetSize, _SetSize) |
| Attributes = property(_GetAttributes, _SetAttributes) |
| Fixed = property(_GetFixed) |
| Checksum = property(_GetCheckSum) |
| Alignment = property(_GetAlignment) |
| State = property(_GetState, _SetState) |
| |
| ## PeImage() class |
| # |
| # A class for PE Image |
| # |
| class PeImage: |
| # |
| # just extract e_lfanew |
| # |
| _DosHeaderFormat = "60x 1I" |
| # |
| # Machine |
| # NumberOfSections |
| # SizeOfOptionalHeader |
| # |
| _FileHeaderFormat = "4x 1H 1H 4x 4x 4x 1H 2x" |
| # |
| # Magic |
| # SizeOfImage |
| # SizeOfHeaders |
| # CheckSum |
| # NumberOfRvaAndSizes |
| # |
| _OptionalHeader32Format = "1H 54x 1I 1I 1I 24x 1I" |
| _OptionalHeader64Format = "" |
| def __init__(self, Buf, Offset, Size): |
| self.Offset = Offset |
| self.Size = Size |
| self.Machine = 0x014c # IA32 |
| self.NumberOfSections = 0 |
| self.SizeOfImage = 0 |
| self.SizeOfOptionalHeader = 0 |
| self.Checksum = 0 |
| self._PeImageBuf = Buf |
| self._SectionList = [] |
| |
| self._DosHeader = struct.Struct(PeImage._DosHeaderFormat) |
| self._FileHeader = struct.Struct(PeImage._FileHeaderFormat) |
| self._OptionalHeader32 = struct.Struct(PeImage._OptionalHeader32Format) |
| |
| self.Buffer = None |
| |
| self._Unpack() |
| |
| def __str__(self): |
| pass |
| |
| def __len__(self): |
| return self.Size |
| |
| def _Unpack(self): |
| # from DOS header, get the offset of PE header |
| FileHeaderOffset, = self._DosHeader.unpack_from(self._PeImageBuf, self.Offset) |
| if FileHeaderOffset < struct.calcsize(self._DosHeaderFormat): |
| EdkLogger.error("PE+", 0, "Invalid offset of IMAGE_FILE_HEADER: %s" % FileHeaderOffset) |
| |
| # from FILE header, get the optional header size |
| self.Machine, self.NumberOfSections, self.SizeOfOptionalHeader = \ |
| self._FileHeader.unpack_from(self._PeImageBuf, self.Offset + FileHeaderOffset) |
| |
| print "Machine=%x NumberOfSections=%x SizeOfOptionalHeader=%x" % (self.Machine, self.NumberOfSections, self.SizeOfOptionalHeader) |
| # optional header follows the FILE header |
| OptionalHeaderOffset = FileHeaderOffset + struct.calcsize(self._FileHeaderFormat) |
| Magic, self.SizeOfImage, SizeOfHeaders, self.Checksum, NumberOfRvaAndSizes = \ |
| self._OptionalHeader32.unpack_from(self._PeImageBuf, self.Offset + OptionalHeaderOffset) |
| print "Magic=%x SizeOfImage=%x SizeOfHeaders=%x, Checksum=%x, NumberOfRvaAndSizes=%x" % (Magic, self.SizeOfImage, SizeOfHeaders, self.Checksum, NumberOfRvaAndSizes) |
| |
| PeImageSectionTableOffset = OptionalHeaderOffset + self.SizeOfOptionalHeader |
| PeSections = PeSectionTable(self._PeImageBuf, self.Offset + PeImageSectionTableOffset, self.NumberOfSections) |
| |
| print "%x" % PeSections.GetFileAddress(0x3920) |
| |
| ## PeSectionTable() class |
| # |
| # A class for PE Section Table |
| # |
| class PeSectionTable: |
| def __init__(self, Buf, Offset, NumberOfSections): |
| self._SectionList = [] |
| |
| SectionHeaderOffset = Offset |
| for TableIndex in range(0, NumberOfSections): |
| SectionHeader = PeSectionHeader(Buf, SectionHeaderOffset) |
| self._SectionList.append(SectionHeader) |
| SectionHeaderOffset += len(SectionHeader) |
| print SectionHeader |
| |
| def GetFileAddress(self, Rva): |
| for PeSection in self._SectionList: |
| if Rva in PeSection: |
| return PeSection[Rva] |
| |
| ## PeSectionHeader() class |
| # |
| # A class for PE Section Header |
| # |
| class PeSectionHeader: |
| # |
| # VirtualAddress |
| # SizeOfRawData |
| # PointerToRawData |
| # |
| _HeaderFormat = "12x 1I 1I 1I 16x" |
| _HeaderLength = struct.calcsize(_HeaderFormat) |
| |
| def __init__(self, Buf, Offset): |
| self.VirtualAddressStart, self.SizeOfRawData, self.PointerToRawData = \ |
| struct.unpack_from(self._HeaderFormat, Buf, Offset) |
| self.VirtualAddressEnd = self.VirtualAddressStart + self.SizeOfRawData - 1 |
| |
| def __str__(self): |
| return "VirtualAddress=%x, SizeOfRawData=%x, PointerToRawData=%x" % (self.VirtualAddressStart, self.SizeOfRawData, self.PointerToRawData) |
| |
| def __len__(self): |
| return self._HeaderLength |
| |
| def __contains__(self, Rva): |
| return Rva >= self.VirtualAddressStart and Rva <= self.VirtualAddressEnd |
| |
| def __getitem__(self, Rva): |
| return Rva - self.VirtualAddressStart + self.PointerToRawData |
| |
| ## LinkMap() class |
| # |
| # A class for Link Map |
| # |
| class LinkMap: |
| _StartFlag = { |
| "MSFT" : re.compile("Address +Publics by Value +Rva\+Base +Lib:Object"), |
| "GCC" : re.compile("^\.(text|bss|data|edata)"), |
| } |
| |
| _MappingFormat = { |
| "MSFT" : re.compile("([0-9a-f]+):([0-9a-f]+)\s+_+([0-9A-Za-z]+)\s+([0-9a-f]+)\s+"), |
| "GCC" : re.compile("^(\.\w)?\s+(0x[0-9a-f]+)\s+_+([0-9A-Za-z]+)"), |
| } |
| |
| def __init__(self, MapFile, MapType="MSFT"): |
| self.File = MapFile |
| self.MapType = MapType |
| self._Globals = {} # global:RVA |
| |
| self._Parse() |
| |
| def _Parse(self): |
| MapFile = open(self.File, 'r') |
| MappingTitle = self._StartFlag[self.MapType] |
| MappingFormat = self._MappingFormat[self.MapType] |
| MappingStart = False |
| try: |
| for Line in MapFile: |
| Line = Line.strip() |
| if not MappingStart: |
| if MappingTitle.match(Line) != None: |
| MappingStart = True |
| continue |
| ResultList = MappingFormat.findall(Line) |
| if len(ResultList) == 0 or len(ResultList[0]) != 4: |
| continue |
| self._Globals[ResultList[2]] = int(ResultList[3], 16) |
| EdkLogger.verbose(ResultList[0]) |
| finally: |
| MapFile.close() |
| |
| def __contains__(self, Var): |
| return Var in self._Globals |
| |
| def __getitem__(self, Var): |
| if Var not in self._Globals: |
| return None |
| return self._Globals[Var] |
| |
| ## MultipleFv() class |
| # |
| # A class for Multiple FV |
| # |
| class MultipleFv(FirmwareVolume): |
| def __init__(self, FvList): |
| FirmwareVolume.__init__(self) |
| self.BasicInfo = [] |
| for FvPath in FvList: |
| FvName = os.path.splitext(os.path.split(FvPath)[1])[0] |
| Fd = open(FvPath, 'rb') |
| Buf = array('B') |
| try: |
| Buf.fromfile(Fd, os.path.getsize(FvPath)) |
| except EOFError: |
| pass |
| |
| Fv = FirmwareVolume(FvName) |
| Fv.frombuffer(Buf, 0, len(Buf)) |
| |
| self.BasicInfo.append([Fv.Name, Fv.FileSystemGuid, Fv.Size]) |
| self.FfsDict.append(Fv.FfsDict) |
| |
| # Version and Copyright |
| __version_number__ = "0.01" |
| __version__ = "%prog Version " + __version_number__ |
| __copyright__ = "Copyright (c) 2008, Intel Corporation. All rights reserved." |
| |
| ## Parse command line options |
| # |
| # Using standard Python module optparse to parse command line option of this tool. |
| # |
| # @retval Options A optparse.Values object containing the parsed options |
| # @retval InputFile Path of file to be trimmed |
| # |
| def GetOptions(): |
| OptionList = [ |
| make_option("-a", "--arch", dest="Arch", |
| help="The input file is preprocessed source code, including C or assembly code"), |
| make_option("-p", "--platform", dest="ActivePlatform", |
| help="The input file is preprocessed VFR file"), |
| make_option("-m", "--module", dest="ActiveModule", |
| help="Convert standard hex format (0xabcd) to MASM format (abcdh)"), |
| make_option("-f", "--FDF-file", dest="FdfFile", |
| help="Convert standard hex format (0xabcd) to MASM format (abcdh)"), |
| make_option("-o", "--output", dest="OutputDirectory", |
| help="File to store the trimmed content"), |
| make_option("-t", "--toolchain-tag", dest="ToolChain", |
| help=""), |
| make_option("-k", "--msft", dest="MakefileType", action="store_const", const="nmake", |
| help=""), |
| make_option("-g", "--gcc", dest="MakefileType", action="store_const", const="gmake", |
| help=""), |
| make_option("-v", "--verbose", dest="LogLevel", action="store_const", const=EdkLogger.VERBOSE, |
| help="Run verbosely"), |
| make_option("-d", "--debug", dest="LogLevel", type="int", |
| help="Run with debug information"), |
| make_option("-q", "--quiet", dest="LogLevel", action="store_const", const=EdkLogger.QUIET, |
| help="Run quietly"), |
| make_option("-?", action="help", help="show this help message and exit"), |
| ] |
| |
| # use clearer usage to override default usage message |
| UsageString = "%prog [-a ARCH] [-p PLATFORM] [-m MODULE] [-t TOOLCHAIN_TAG] [-k] [-g] [-v|-d <debug_level>|-q] [-o <output_directory>] [GenC|GenMake]" |
| |
| Parser = OptionParser(description=__copyright__, version=__version__, option_list=OptionList, usage=UsageString) |
| Parser.set_defaults(Arch=[]) |
| Parser.set_defaults(ActivePlatform=None) |
| Parser.set_defaults(ActiveModule=None) |
| Parser.set_defaults(OutputDirectory="build") |
| Parser.set_defaults(FdfFile=None) |
| Parser.set_defaults(ToolChain="MYTOOLS") |
| if sys.platform == "win32": |
| Parser.set_defaults(MakefileType="nmake") |
| else: |
| Parser.set_defaults(MakefileType="gmake") |
| Parser.set_defaults(LogLevel=EdkLogger.INFO) |
| |
| Options, Args = Parser.parse_args() |
| |
| # error check |
| if len(Args) == 0: |
| Options.Target = "genmake" |
| sys.argv.append("genmake") |
| elif len(Args) == 1: |
| Options.Target = Args[0].lower() |
| if Options.Target not in ["genc", "genmake"]: |
| EdkLogger.error("AutoGen", OPTION_NOT_SUPPORTED, "Not supported target", |
| ExtraData="%s\n\n%s" % (Options.Target, Parser.get_usage())) |
| else: |
| EdkLogger.error("AutoGen", OPTION_NOT_SUPPORTED, "Too many targets", |
| ExtraData=Parser.get_usage()) |
| |
| return Options |
| |
| ## Entrance method |
| # |
| # This method mainly dispatch specific methods per the command line options. |
| # If no error found, return zero value so the caller of this tool can know |
| # if it's executed successfully or not. |
| # |
| # @retval 0 Tool was successful |
| # @retval 1 Tool failed |
| # |
| def Main(): |
| from build import build |
| try: |
| Option = GetOptions() |
| build.main() |
| except Exception, e: |
| print e |
| return 1 |
| |
| return 0 |
| |
| # This acts like the main() function for the script, unless it is 'import'ed into another script. |
| if __name__ == '__main__': |
| EdkLogger.Initialize() |
| # sys.exit(Main()) |
| |
| if len(sys.argv) > 1: |
| FilePath = sys.argv[1] |
| if FilePath.lower().endswith(".fv"): |
| fd = open(FilePath, 'rb') |
| buf = array('B') |
| try: |
| buf.fromfile(fd, os.path.getsize(FilePath)) |
| except EOFError: |
| pass |
| |
| fv = FirmwareVolume("FVRECOVERY") |
| fv.frombuffer(buf, 0, len(buf)) |
| #fv.Dispatch(None) |
| print fv |
| elif FilePath.endswith(".efi"): |
| fd = open(FilePath, 'rb') |
| buf = array('B') |
| Size = os.path.getsize(FilePath) |
| |
| try: |
| buf.fromfile(fd, Size) |
| except EOFError: |
| pass |
| |
| PeSection = Section(Type=0x10) |
| PeSection.Data = buf |
| sf, ext = os.path.splitext(os.path.basename(FilePath)) |
| sf += ".sec" |
| PeSection.tofile(open(sf, 'wb')) |
| elif FilePath.endswith(".map"): |
| mf = LinkMap(FilePath) |
