private static StreamHeader ReadStreamHeader(MemoryCursor/*!*/ c)
{
StreamHeader header = new StreamHeader();
header.offset = c.ReadInt32();
header.size = c.ReadInt32();
header.name = c.ReadASCII();
int n = header.name.Length + 1;
c.Position += (4 - (n % 4)) % 4;
return header;
}
private static TablesHeader/*!*/ ReadTablesHeader(MemoryCursor/*!*/ c)
{
TablesHeader header = new TablesHeader();
header.reserved = c.ReadInt32(); // Must be zero
header.majorVersion = c.ReadByte(); // Must be one
header.minorVersion = c.ReadByte(); // Must be zero
header.heapSizes = c.ReadByte(); // Bits for heap sizes
header.rowId = c.ReadByte(); // log-base-2 of largest rowId
header.maskValid = c.ReadInt64(); // Present table counts
header.maskSorted = c.ReadInt64(); // Sorted tables
int n = 0;
ulong mask = (ulong)header.maskValid;
while (mask != 0)
{
if (mask % 2 == 1) n++;
mask /= 2;
}
int[] countArray = header.countArray = new int[n];
for (int i = 0; i < n; i++)
countArray[i] = c.ReadInt32();
return header;
}
private static MetadataHeader/*!*/ ReadMetadataHeader(MemoryCursor/*!*/ c)
{
MetadataHeader header = new MetadataHeader();
header.signature = c.ReadInt32();
if (header.signature != 0x424a5342)
throw new InvalidMetadataException(ExceptionStrings.BadMetadataHeaderSignature);
header.majorVersion = c.ReadUInt16();
header.minorVersion = c.ReadUInt16();
header.reserved = c.ReadInt32();
int len = c.ReadInt32();
header.versionString = c.ReadASCII(len);
while (len++ % 4 != 0) c.ReadByte();
header.flags = c.ReadUInt16();
int n = c.ReadUInt16();
StreamHeader[] streamHeaders = header.streamHeaders = new StreamHeader[n];
for (int i = 0; i < n; i++)
streamHeaders[i] = ReadStreamHeader(c);
return header;
}
internal static NTHeader/*!*/ ReadNTHeader(MemoryCursor/*!*/ c)
{
NTHeader header = new NTHeader();
header.signature = c.ReadInt32();
header.machine = c.ReadUInt16();
header.numberOfSections = c.ReadUInt16();
header.timeDateStamp = c.ReadInt32();
header.pointerToSymbolTable = c.ReadInt32();
header.numberOfSymbols = c.ReadInt32();
header.sizeOfOptionalHeader = c.ReadUInt16();
header.characteristics = c.ReadUInt16();
header.magic = c.ReadUInt16();
header.majorLinkerVersion = c.ReadByte();
header.minorLinkerVersion = c.ReadByte();
header.sizeOfCode = c.ReadInt32();
header.sizeOfInitializedData = c.ReadInt32();
header.sizeOfUninitializedData = c.ReadInt32();
header.addressOfEntryPoint = c.ReadInt32();
header.baseOfCode = c.ReadInt32();
if (header.magic == 0x10B)
{
header.baseOfData = c.ReadInt32();
header.imageBase = c.ReadInt32();
}
else
{
header.baseOfData = 0;
header.imageBase = c.ReadInt64();
}
header.sectionAlignment = c.ReadInt32();
header.fileAlignment = c.ReadInt32();
header.majorOperatingSystemVersion = c.ReadUInt16();
header.minorOperatingSystemVersion = c.ReadUInt16();
header.majorImageVersion = c.ReadUInt16();
header.minorImageVersion = c.ReadUInt16();
header.majorSubsystemVersion = c.ReadUInt16();
header.minorSubsystemVersion = c.ReadUInt16();
header.win32VersionValue = c.ReadInt32();
header.sizeOfImage = c.ReadInt32();
header.sizeOfHeaders = c.ReadInt32();
header.checkSum = c.ReadInt32();
header.subsystem = c.ReadUInt16();
header.dllCharacteristics = c.ReadUInt16();
if (header.magic == 0x10B)
{
header.sizeOfStackReserve = c.ReadInt32();
header.sizeOfStackCommit = c.ReadInt32();
header.sizeOfHeapReserve = c.ReadInt32();
header.sizeOfHeapCommit = c.ReadInt32();
}
else
{
header.sizeOfStackReserve = c.ReadInt64();
header.sizeOfStackCommit = c.ReadInt64();
header.sizeOfHeapReserve = c.ReadInt64();
header.sizeOfHeapCommit = c.ReadInt64();
}
header.loaderFlags = c.ReadInt32();
header.numberOfDataDirectories = c.ReadInt32();
// Verify that the header signature and magic number are valid
if (header.signature != 0x00004550 /* "PE\0\0" */)
throw new InvalidMetadataException(ExceptionStrings.BadCOFFHeaderSignature);
if (header.magic != 0x010B && header.magic != 0x020B)
throw new InvalidMetadataException(ExceptionStrings.BadPEHeaderMagicNumber);
//Read the data directories
header.exportTable = ReadDirectoryEntry(c);
header.importTable = ReadDirectoryEntry(c);
header.resourceTable = ReadDirectoryEntry(c);
header.exceptionTable = ReadDirectoryEntry(c);
header.certificateTable = ReadDirectoryEntry(c);
header.baseRelocationTable = ReadDirectoryEntry(c);
header.debugTable = ReadDirectoryEntry(c);
header.copyrightTable = ReadDirectoryEntry(c);
header.globalPointerTable = ReadDirectoryEntry(c);
header.threadLocalStorageTable = ReadDirectoryEntry(c);
header.loadConfigTable = ReadDirectoryEntry(c);
header.boundImportTable = ReadDirectoryEntry(c);
header.importAddressTable = ReadDirectoryEntry(c);
header.delayImportTable = ReadDirectoryEntry(c);
header.cliHeaderTable = ReadDirectoryEntry(c);
header.reserved = ReadDirectoryEntry(c);
return header;
}
private Win32Resource ReadWin32ResourceDataEntry(MemoryCursor/*!*/ c, int position,
string TypeName, int TypeID, string Name, int ID, int LanguageID)
{
Win32Resource rsrc = new Win32Resource();
rsrc.TypeName = TypeName;
rsrc.TypeId = TypeID;
rsrc.Name = Name;
rsrc.Id = ID;
rsrc.LanguageId = LanguageID;
c = new MemoryCursor(c);
c.Position = position;
int dataRVA = c.ReadInt32();
int dataSize = c.ReadInt32();
rsrc.CodePage = c.ReadInt32();
c.Position = this.RvaToOffset(dataRVA);
rsrc.Data = c.ReadBytes(dataSize);
return rsrc;
}
private static int ReadWin32ResourceDirectoryHeader(MemoryCursor/*!*/ c)
{
c.ReadInt32(); //Characteristics
c.ReadInt32(); //TimeDate stamp
c.ReadInt32(); //Version
int numberOfNamedEntries = c.ReadUInt16();
int numberOfIdEntries = c.ReadUInt16();
return numberOfNamedEntries + numberOfIdEntries;
}
internal Win32ResourceList ReadWin32Resources()
{
Win32ResourceList rs = new Win32ResourceList();
int startPos = this.win32ResourcesOffset;
if (startPos < 0) return rs;
MemoryCursor c = this.cursor;
c.Position = startPos;
int sizeOfTypeDirectory = ReadWin32ResourceDirectoryHeader(c);
for (int i = 0; i < sizeOfTypeDirectory; i++)
{
string TypeName = null;
int TypeID = c.ReadInt32();
if (TypeID < 0)
{
MemoryCursor nac = new MemoryCursor(c);
nac.Position = startPos + (TypeID & 0x7FFFFFFF);
int strLength = nac.ReadUInt16();
TypeName = nac.ReadUTF16(strLength);
}
int offset = c.ReadInt32();
if (offset >= 0)
rs.Add(this.ReadWin32ResourceDataEntry(c, startPos + offset, TypeName, TypeID, null, 0, 0));
else
{
MemoryCursor nc = new MemoryCursor(c);
nc.Position = startPos + (offset & 0x7FFFFFFF);
int sizeOfNameDirectory = ReadWin32ResourceDirectoryHeader(nc);
for (int j = 0; j < sizeOfNameDirectory; j++)
{
string Name = null;
int ID = nc.ReadInt32();
if (ID < 0)
{
MemoryCursor nac = new MemoryCursor(c);
int strLength = nac.ReadUInt16();
Name = nac.ReadUTF16(strLength);
}
offset = nc.ReadInt32();
if (offset >= 0)
rs.Add(this.ReadWin32ResourceDataEntry(c, startPos + offset, TypeName, TypeID, Name, ID, 0));
else
{
MemoryCursor lc = new MemoryCursor(c);
lc.Position = startPos + (offset & 0x7FFFFFFF);
int sizeOfLanguageDirectory = ReadWin32ResourceDirectoryHeader(lc);
for (int k = 0; k < sizeOfLanguageDirectory; k++)
{
int LanguageID = lc.ReadInt32();
offset = lc.ReadInt32();
rs.Add(this.ReadWin32ResourceDataEntry(c, startPos + offset, TypeName, TypeID, Name, ID, LanguageID));
}
}
}
}
}
return rs;
}
private object GetCustomAttributeLiteralValue(MemoryCursor/*!*/ sigReader, ref TypeNode/*!*/ type)
{
if (type == null) return sigReader.ReadInt32();
switch (type.typeCode)
{
case ElementType.Boolean: return sigReader.ReadBoolean();
case ElementType.Char: return sigReader.ReadChar();
case ElementType.Double: return sigReader.ReadDouble();
case ElementType.Single: return sigReader.ReadSingle();
case ElementType.Int16: return sigReader.ReadInt16();
case ElementType.Int32: return sigReader.ReadInt32();
case ElementType.Int64: return sigReader.ReadInt64();
case ElementType.Int8: return sigReader.ReadSByte();
case ElementType.UInt16: return sigReader.ReadUInt16();
case ElementType.UInt32: return sigReader.ReadUInt32();
case ElementType.UInt64: return sigReader.ReadUInt64();
case ElementType.UInt8: return sigReader.ReadByte();
case ElementType.String: return ReadSerString(sigReader);
case ElementType.ValueType:
EnumNode etype = GetCustomAttributeEnumNode(ref type);
return this.GetCustomAttributeLiteralValue(sigReader, etype.UnderlyingType);
case ElementType.Class: return this.GetTypeFromSerializedName(ReadSerString(sigReader));
case ElementType.SzArray:
int numElems = sigReader.ReadInt32();
TypeNode elemType = ((ArrayType)type).ElementType;
return this.GetCustomAttributeLiteralArray(sigReader, numElems, elemType);
case ElementType.Object:
{
type = this.ParseTypeSignature(sigReader);
return this.GetCustomAttributeLiteralValue(sigReader, ref type);
}
}
throw new InvalidMetadataException(ExceptionStrings.UnexpectedTypeInCustomAttribute);
}
private AttributeNode GetPermissionAttribute(MemoryCursor/*!*/ sigReader)
{
sigReader.ReadInt32(); //Skip over index
int typeNameLength = sigReader.ReadInt32();
sigReader.ReadUTF8(typeNameLength); //Skip over type name
int constructorToken = sigReader.ReadInt32();
sigReader.ReadInt32(); //Skip over attribute type token
sigReader.ReadInt32(); //Skip over assembly ref token
int caBlobLength = sigReader.ReadInt32();
sigReader.ReadInt32(); //Skip over the number of parameters in the CA blob
TypeNodeList varArgTypes; //Ignored because vararg constructors are not allowed in Custom Attributes
Method cons = this.GetConstructorDefOrRef(constructorToken, out varArgTypes);
if (cons == null) cons = new Method();
return this.GetCustomAttribute(cons, sigReader, caBlobLength);
}
