_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
+ def __init__(self, CompressedData=None, CompressionType=None, UncompressedLength=None):\r
+ Image.__init__(self)\r
if UncompressedLength is not None:\r
- m.UncompressedLength = UncompressedLength\r
+ self.UncompressedLength = UncompressedLength\r
if CompressionType is not None:\r
- m.CompressionType = CompressionType\r
+ self.CompressionType = CompressionType\r
if CompressedData is not None:\r
- m.Data = CompressedData\r
+ self.Data = CompressedData\r
\r
- def __str__(m):\r
+ def __str__(self):\r
global gIndention\r
- S = "algorithm=%s uncompressed=%x" % (m.CompressionType, m.UncompressedLength)\r
- for Sec in m.Sections:\r
+ S = "algorithm=%s uncompressed=%x" % (self.CompressionType, self.UncompressedLength)\r
+ for Sec in self.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
+ def _SetOriginalSize(self, Size):\r
+ self.SetField(self._ORIG_SIZE_, 0, Size)\r
\r
- def _GetOriginalSize(m):\r
- return m.GetField(m._ORIG_SIZE_)[0]\r
+ def _GetOriginalSize(self):\r
+ return self.GetField(self._ORIG_SIZE_)[0]\r
\r
- def _SetCompressionType(m, Type):\r
- m.SetField(m._CMPRS_TYPE_, 0, Type)\r
+ def _SetCompressionType(self, Type):\r
+ self.SetField(self._CMPRS_TYPE_, 0, Type)\r
\r
- def _GetCompressionType(m):\r
- return m.GetField(m._CMPRS_TYPE_)[0]\r
+ def _GetCompressionType(self):\r
+ return self.GetField(self._CMPRS_TYPE_)[0]\r
\r
- def _GetSections(m):\r
+ def _GetSections(self):\r
try:\r
from . import EfiCompressor\r
TmpData = EfiCompressor.FrameworkDecompress(\r
- m[m._HEADER_SIZE_:],\r
- len(m) - m._HEADER_SIZE_\r
+ self[self._HEADER_SIZE_:],\r
+ len(self) - self._HEADER_SIZE_\r
)\r
DecData = array('B')\r
DecData.fromstring(TmpData)\r
except:\r
from . import EfiCompressor\r
TmpData = EfiCompressor.UefiDecompress(\r
- m[m._HEADER_SIZE_:],\r
- len(m) - m._HEADER_SIZE_\r
+ self[self._HEADER_SIZE_:],\r
+ len(self) - self._HEADER_SIZE_\r
)\r
DecData = array('B')\r
DecData.fromstring(TmpData)\r
_HEADER_ = struct.Struct("")\r
_HEADER_SIZE_ = 0\r
\r
- def __init__(m):\r
- Image.__init__(m)\r
+ def __init__(self):\r
+ Image.__init__(self)\r
\r
- def __str__(m):\r
- return m.String\r
+ def __str__(self):\r
+ return self.String\r
\r
- def _Unpack(m):\r
+ def _Unpack(self):\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
+ self.empty()\r
+ self.extend(self._BUF_[self._OFF_ : self._OFF_ + self._LEN_])\r
+ return len(self)\r
\r
- def _GetUiString(m):\r
- return codecs.utf_16_decode(m[0:-2].tostring())[0]\r
+ def _GetUiString(self):\r
+ return codecs.utf_16_decode(self[0:-2].tostring())[0]\r
\r
String = property(_GetUiString)\r
\r
0x09 : _OPCODE_, #"SOR"\r
}\r
\r
- def __init__(m):\r
- Image.__init__(m)\r
- m._ExprList = []\r
+ def __init__(self):\r
+ Image.__init__(self)\r
+ self._ExprList = []\r
\r
- def __str__(m):\r
+ def __str__(self):\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
+ for T in self.Expression:\r
+ if T in self._OPCODE_STRING_:\r
+ S += Indention + self._OPCODE_STRING_[T]\r
if T not in [0x00, 0x01, 0x02]:\r
S += '\n'\r
else:\r
gIndention -= 4\r
return S\r
\r
- def _Unpack(m):\r
+ def _Unpack(self):\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
+ self.empty()\r
+ self.extend(self._BUF_[self._OFF_ : self._OFF_ + self._LEN_])\r
+ return len(self)\r
\r
- def _GetExpression(m):\r
- if m._ExprList == []:\r
+ def _GetExpression(self):\r
+ if self._ExprList == []:\r
Offset = 0\r
- CurrentData = m._OPCODE_\r
- while Offset < len(m):\r
- Token = CurrentData.unpack_from(m, Offset)\r
+ CurrentData = self._OPCODE_\r
+ while Offset < len(self):\r
+ Token = CurrentData.unpack_from(self, 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
+ if Token in self._NEXT_:\r
+ CurrentData = self._NEXT_[Token]\r
else:\r
- CurrentData = m._GUID_\r
+ CurrentData = self._GUID_\r
else:\r
- CurrentData = m._OPCODE_\r
- m._ExprList.append(Token)\r
+ CurrentData = self._OPCODE_\r
+ self._ExprList.append(Token)\r
if CurrentData is None:\r
break\r
- return m._ExprList\r
+ return self._ExprList\r
\r
Expression = property(_GetExpression)\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
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 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 LoadProtocol(self, Db, ModuleGuid):\r
RecordSet = Db.TblReport.Exec(SqlCommand)\r
if RecordSet != []:\r
FfsName = RecordSet[0][0]\r
-\r
if IsInstalled:\r
self.DisPatchDxe(Db)\r
\r
if IsInstalled:\r
self.DisPatchPei(Db)\r
\r
-\r
def __str__(self):\r
global gIndention\r
gIndention += 4\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
+ def __init__(self, SectionDefinitionGuid=None, DataOffset=None, Attributes=None, Data=None):\r
+ Image.__init__(self)\r
if SectionDefinitionGuid is not None:\r
- m.SectionDefinitionGuid = SectionDefinitionGuid\r
+ self.SectionDefinitionGuid = SectionDefinitionGuid\r
if DataOffset is not None:\r
- m.DataOffset = DataOffset\r
+ self.DataOffset = DataOffset\r
if Attributes is not None:\r
- m.Attributes = Attributes\r
+ self.Attributes = Attributes\r
if Data is not None:\r
- m.Data = Data\r
+ self.Data = Data\r
\r
- def __str__(m):\r
- S = "guid=%s" % (gGuidStringFormat % m.SectionDefinitionGuid)\r
- for Sec in m.Sections:\r
+ def __str__(self):\r
+ S = "guid=%s" % (gGuidStringFormat % self.SectionDefinitionGuid)\r
+ for Sec in self.Sections:\r
S += "\n" + str(Sec)\r
return S\r
\r
- def _Unpack(m):\r
+ def _Unpack(self):\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
+ self.empty()\r
+ self.extend(self._BUF_[self._OFF_ : self._OFF_ + self._LEN_])\r
+ return len(self)\r
\r
- def _SetAttribute(m, Attribute):\r
- m.SetField(m._ATTR_, 0, Attribute)\r
+ def _SetAttribute(self, Attribute):\r
+ self.SetField(self._ATTR_, 0, Attribute)\r
\r
- def _GetAttribute(m):\r
- return m.GetField(m._ATTR_)[0]\r
+ def _GetAttribute(self):\r
+ return self.GetField(self._ATTR_)[0]\r
\r
- def _SetGuid(m, Guid):\r
- m.SetField(m._GUID_, 0, Guid)\r
+ def _SetGuid(self, Guid):\r
+ self.SetField(self._GUID_, 0, Guid)\r
\r
- def _GetGuid(m):\r
- return m.GetField(m._GUID_)\r
+ def _GetGuid(self):\r
+ return self.GetField(self._GUID_)\r
\r
- def _SetDataOffset(m, Offset):\r
- m.SetField(m._DATA_OFFSET_, 0, Offset)\r
+ def _SetDataOffset(self, Offset):\r
+ self.SetField(self._DATA_OFFSET_, 0, Offset)\r
\r
- def _GetDataOffset(m):\r
- return m.GetField(m._DATA_OFFSET_)[0]\r
+ def _GetDataOffset(self):\r
+ return self.GetField(self._DATA_OFFSET_)[0]\r
\r
- def _GetSections(m):\r
+ def _GetSections(self):\r
SectionList = []\r
- Guid = gGuidStringFormat % m.SectionDefinitionGuid\r
- if Guid == m.CRC32_GUID:\r
+ Guid = gGuidStringFormat % self.SectionDefinitionGuid\r
+ if Guid == self.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
+ Offset = self.DataOffset - 4\r
+ while Offset < len(self):\r
Sec = Section()\r
try:\r
- Sec.frombuffer(m, Offset)\r
+ Sec.frombuffer(self, 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
+ elif Guid == self.TIANO_COMPRESS_GUID:\r
try:\r
from . import EfiCompressor\r
# skip the header\r
- Offset = m.DataOffset - 4\r
- TmpData = EfiCompressor.FrameworkDecompress(m[Offset:], len(m)-Offset)\r
+ Offset = self.DataOffset - 4\r
+ TmpData = EfiCompressor.FrameworkDecompress(self[Offset:], len(self)-Offset)\r
DecData = array('B')\r
DecData.fromstring(TmpData)\r
Offset = 0\r
SectionList.append(Sec)\r
except:\r
pass\r
- elif Guid == m.LZMA_COMPRESS_GUID:\r
+ elif Guid == self.LZMA_COMPRESS_GUID:\r
try:\r
from . import LzmaCompressor\r
# skip the header\r
- Offset = m.DataOffset - 4\r
- TmpData = LzmaCompressor.LzmaDecompress(m[Offset:], len(m)-Offset)\r
+ Offset = self.DataOffset - 4\r
+ TmpData = LzmaCompressor.LzmaDecompress(self[Offset:], len(self)-Offset)\r
DecData = array('B')\r
DecData.fromstring(TmpData)\r
Offset = 0\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
+ def __init__(self, Type=None, Size=None):\r
+ Image.__init__(self)\r
+ self._Alignment = 1\r
if Type is not None:\r
- m.Type = Type\r
+ self.Type = Type\r
if Size is not None:\r
- m.Size = Size\r
+ self.Size = Size\r
\r
- def __str__(m):\r
+ def __str__(self):\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
+ if self.Type in self._TypeName:\r
+ SectionInfo += "[SECTION:%s] offset=%x size=%x" % (self._TypeName[self.Type], self._OFF_, self.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
+ SectionInfo += "[SECTION:%x<unknown>] offset=%x size=%x " % (self.Type, self._OFF_, self.Size)\r
+ for Offset in self._SubImages:\r
+ SectionInfo += ", " + str(self._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
+ def _Unpack(self):\r
+ self.empty()\r
+ Type, = self._TYPE_.unpack_from(self._BUF_, self._OFF_)\r
+ Size1, Size2, Size3 = self._SIZE_.unpack_from(self._BUF_, self._OFF_)\r
Size = Size1 + (Size2 << 8) + (Size3 << 16)\r
\r
- if Type not in m._SectionSubImages:\r
+ if Type not in self._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
+ self.extend(self._BUF_[self._OFF_ : self._OFF_ + Size])\r
else:\r
# keep header in this Image object\r
- m.extend(m._BUF_[m._OFF_ : m._OFF_ + m._HEADER_SIZE_])\r
+ self.extend(self._BUF_[self._OFF_ : self._OFF_ + self._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
+ PayloadOffset = self._HEADER_SIZE_\r
+ PayloadLen = self.Size - self._HEADER_SIZE_\r
+ Payload = self._SectionSubImages[self.Type]()\r
+ Payload.frombuffer(self._BUF_, self._OFF_ + self._HEADER_SIZE_, PayloadLen)\r
+ self._SubImages[PayloadOffset] = Payload\r
\r
return Size\r
\r
- def _SetSize(m, Size):\r
+ def _SetSize(self, 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
+ self.SetField(self._SIZE_, 0, Size1, Size2, Size3)\r
\r
- def _GetSize(m):\r
- Size1, Size2, Size3 = m.GetField(m._SIZE_)\r
+ def _GetSize(self):\r
+ Size1, Size2, Size3 = self.GetField(self._SIZE_)\r
return Size1 + (Size2 << 8) + (Size3 << 16)\r
\r
- def _SetType(m, Type):\r
- m.SetField(m._TYPE_, 0, Type)\r
+ def _SetType(self, Type):\r
+ self.SetField(self._TYPE_, 0, Type)\r
\r
- def _GetType(m):\r
- return m.GetField(m._TYPE_)[0]\r
+ def _GetType(self):\r
+ return self.GetField(self._TYPE_)[0]\r
\r
- def _GetAlignment(m):\r
- return m._Alignment\r
+ def _GetAlignment(self):\r
+ return self._Alignment\r
\r
- def _SetAlignment(m, Alignment):\r
- m._Alignment = Alignment\r
+ def _SetAlignment(self, Alignment):\r
+ self._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
+ PayloadOffset = self._OFF_ + self._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
+ while (NewOffset - PayloadOffset) < self._HEADER_SIZE_:\r
+ NewOffset += self._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
+ def tofile(self, f):\r
+ self.Size = len(self)\r
+ Image.tofile(self, f)\r
+ for Offset in self._SubImages:\r
+ self._SubImages[Offset].tofile(f)\r
\r
Type = property(_GetType, _SetType)\r
Size = property(_GetSize, _SetSize)\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
+ def _SetSize(self, 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
+ self.SetField(self._SIZE_, 0, Size1, Size2, Size3)\r
\r
- def _GetSize(m):\r
- Size1, Size2, Size3 = m.GetField(m._SIZE_)\r
+ def _GetSize(self):\r
+ Size1, Size2, Size3 = self.GetField(self._SIZE_)\r
return Size1 + (Size2 << 8) + (Size3 << 16)\r
\r
- def _SetType(m, Type):\r
- m.SetField(m._TYPE_, 0, Type)\r
+ def _SetType(self, Type):\r
+ self.SetField(self._TYPE_, 0, Type)\r
\r
- def _GetType(m):\r
- return m.GetField(m._TYPE_)[0]\r
+ def _GetType(self):\r
+ return self.GetField(self._TYPE_)[0]\r
\r
def _SetAttributes(self, Value):\r
- self.SetField(m._ATTR_, 0, Value)\r
+ self.SetField(self._ATTR_, 0, Value)\r
\r
def _GetAttributes(self):\r
return self.GetField(self._ATTR_)[0]\r
return (self.Attributes & self.FFS_ATTRIB_DATA_ALIGNMENT) >> 3\r
\r
def _SetState(self, Value):\r
- self.SetField(m._STATE_, 0, Value)\r
+ self.SetField(self._STATE_, 0, Value)\r
\r
def _GetState(self):\r
- return self.GetField(m._STATE_)[0]\r
+ return self.GetField(self._STATE_)[0]\r
\r
Name = property(_GetName, _SetName)\r
Guid = property(_GetGuid)\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
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