[mirror_edk2.git] / BaseTools / Source / Python / Eot / FvImage.py

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