| ## @file | |
| # Parse FV image | |
| # | |
| # Copyright (c) 2008 - 2014, 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 Common.LongFilePathOs as 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 Common.LongFilePathSupport import OpenLongFilePath as open | |
| 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) |