/// <inheritdoc />
protected override IList <IResourceEntry> GetEntries()
{
var result = new OwnedCollection <IResourceDirectory, IResourceEntry>(this);
// Optimisation, check for invalid resource directory offset, and prevention of self loop:
if (_namedEntries + _idEntries == 0 || _depth >= MaxDepth)
{
return(result);
}
uint baseRva = _peFile.OptionalHeader.DataDirectories[OptionalHeader.ResourceDirectoryIndex].VirtualAddress;
// Create entries reader.
uint entryListSize = (uint)((_namedEntries + _idEntries) * ResourceDirectoryEntry.EntrySize);
var entriesReader = _peFile.CreateReaderAtFileOffset(_entriesOffset, entryListSize);
for (int i = 0; i < _namedEntries + _idEntries; i++)
{
var rawEntry = new ResourceDirectoryEntry(_peFile, entriesReader);
// Note: Even if creating the directory reader fails, we still want to include the directory entry
// itself. In such a case, we expose the directory as an empty directory. This is why the
// following statement is not used as a condition for an if statement.
_peFile.TryCreateReaderAtRva(baseRva + rawEntry.DataOrSubDirOffset, out var entryReader);
result.Add(rawEntry.IsSubDirectory
? (IResourceEntry) new SerializedResourceDirectory(_peFile, rawEntry, entryReader, _depth + 1)
: new SerializedResourceData(_peFile, rawEntry, entryReader));
}
return(result);
}
/// <inheritdoc />
protected override IList <ModuleDefinition> GetModules()
{
_manifestModule.Assembly = null;
var result = new OwnedCollection <AssemblyDefinition, ModuleDefinition>(this)
{
_manifestModule
};
var moduleResolver = _readParameters.ModuleResolver;
if (moduleResolver != null)
{
var tablesStream = _dotNetDirectory.Metadata.GetStream <TablesStream>();
var stringsStream = _dotNetDirectory.Metadata.GetStream <StringsStream>();
var filesTable = tablesStream.GetTable <FileReferenceRow>(TableIndex.File);
foreach (var fileRow in filesTable)
{
if (fileRow.Attributes == FileAttributes.ContainsMetadata)
{
string name = stringsStream.GetStringByIndex(fileRow.Name);
var module = moduleResolver.Resolve(name);
if (module != null)
{
result.Add(module);
}
}
}
}
return(result);
}
/// <inheritdoc />
protected override IList <ImportedSymbol> GetSymbols()
{
var result = new OwnedCollection <IImportedModule, ImportedSymbol>(this);
if (IsEmpty)
{
return(result);
}
bool is32Bit = _context.File.OptionalHeader.Magic == OptionalHeaderMagic.Pe32;
(ulong ordinalMask, int pointerSize) = is32Bit
? (0x8000_0000ul, sizeof(uint))
: (0x8000_0000_0000_0000ul, sizeof(ulong));
if (!_context.File.TryCreateReaderAtRva(_lookupRva, out var lookupItemReader))
{
_context.BadImage($"Imported module \"{Name}\" has an invalid import lookup thunk table RVA.");
return(result);
}
while (true)
{
ImportedSymbol entry;
ulong lookupItem = lookupItemReader.ReadNativeInt(is32Bit);
if (lookupItem == 0)
{
break;
}
if ((lookupItem & ordinalMask) != 0)
{
entry = new ImportedSymbol((ushort)(lookupItem & 0xFFFF));
}
else
{
uint hintNameRva = (uint)(lookupItem & 0xFFFFFFFF);
if (!_context.File.TryCreateReaderAtRva(hintNameRva, out var reader))
{
_context.BadImage($"Invalid Hint-Name RVA for import {Name}!#{result.Count.ToString()}.");
entry = new ImportedSymbol(0, "<<<INVALID_NAME_RVA>>>");
}
else
{
entry = new ImportedSymbol(reader.ReadUInt16(), reader.ReadAsciiString());
}
}
entry.AddressTableEntry = _context.File.GetReferenceToRva((uint)(_addressRva + result.Count * pointerSize));
result.Add(entry);
}
return(result);
}
private IList <TMember> CreateMemberCollection <TMember>(MetadataRange range)
where TMember : class, IMetadataMember, IOwnedCollectionElement <TypeDefinition>
{
var result = new OwnedCollection <TypeDefinition, TMember>(this);
foreach (var token in range)
{
result.Add((TMember)_parentModule.LookupMember(token));
}
return(result);
}
/// <inheritdoc />
protected override IList <GenericParameterConstraint> GetConstraints()
{
var result = new OwnedCollection <GenericParameter, GenericParameterConstraint>(this);
foreach (uint rid in _parentModule.GetGenericParameterConstraints(MetadataToken))
{
var constraintToken = new MetadataToken(TableIndex.GenericParamConstraint, rid);
result.Add((GenericParameterConstraint)_parentModule.LookupMember(constraintToken));
}
return(result);
}
internal IList <SecurityDeclaration> GetSecurityDeclarationCollection(IHasSecurityDeclaration owner)
{
EnsureSecurityDeclarationsInitialized();
var result = new OwnedCollection <IHasSecurityDeclaration, SecurityDeclaration>(owner);
foreach (uint rid in _securityDeclarations.GetValues(owner.MetadataToken))
{
var attribute = (SecurityDeclaration)LookupMember(new MetadataToken(TableIndex.DeclSecurity, rid));
result.Add(attribute);
}
return(result);
}
internal IList <CustomAttribute> GetCustomAttributeCollection(IHasCustomAttribute owner)
{
EnsureCustomAttributesInitialized();
var result = new OwnedCollection <IHasCustomAttribute, CustomAttribute>(owner);
foreach (uint rid in _customAttributes.GetValues(owner.MetadataToken))
{
var attribute = (CustomAttribute)LookupMember(new MetadataToken(TableIndex.CustomAttribute, rid));
result.Add(attribute);
}
return(result);
}
/// <inheritdoc />
protected override IList <TypeDefinition> GetNestedTypes()
{
var result = new OwnedCollection <TypeDefinition, TypeDefinition>(this);
var rids = _parentModule.GetNestedTypeRids(MetadataToken.Rid);
foreach (uint rid in rids)
{
var nestedType = (TypeDefinition)_parentModule.LookupMember(new MetadataToken(TableIndex.TypeDef, rid));
result.Add(nestedType);
}
return(result);
}
/// <inheritdoc />
protected override IList <ParameterDefinition> GetParameterDefinitions()
{
var result = new OwnedCollection <MethodDefinition, ParameterDefinition>(this);
foreach (var token in _parentModule.GetParameterRange(MetadataToken.Rid))
{
if (_parentModule.TryLookupMember(token, out var member) && member is ParameterDefinition parameter)
{
result.Add(parameter);
}
}
return(result);
}
/// <inheritdoc />
protected override IList <GenericParameter> GetGenericParameters()
{
var result = new OwnedCollection <IHasGenericParameters, GenericParameter>(this);
foreach (uint rid in _parentModule.GetGenericParameters(MetadataToken))
{
if (_parentModule.TryLookupMember(new MetadataToken(TableIndex.GenericParam, rid), out var member) &&
member is GenericParameter genericParameter)
{
result.Add(genericParameter);
}
}
return(result);
}
/// <inheritdoc />
protected override IList <InterfaceImplementation> GetInterfaces()
{
var result = new OwnedCollection <TypeDefinition, InterfaceImplementation>(this);
var rids = _parentModule.GetInterfaceImplementationRids(MetadataToken);
foreach (uint rid in rids)
{
if (_parentModule.TryLookupMember(new MetadataToken(TableIndex.InterfaceImpl, rid), out var member) &&
member is InterfaceImplementation type)
{
result.Add(type);
}
}
return(result);
}
/// <inheritdoc />
protected override IList <AssemblyReference> GetAssemblyReferences()
{
var result = new OwnedCollection <ModuleDefinition, AssemblyReference>(this);
var table = DotNetDirectory.Metadata
.GetStream <TablesStream>()
.GetTable <AssemblyReferenceRow>(TableIndex.AssemblyRef);
// Don't use the member factory here, this method may be called before the member factory is initialized.
for (int i = 0; i < table.Count; i++)
{
var token = new MetadataToken(TableIndex.AssemblyRef, (uint)i + 1);
result.Add(new SerializedAssemblyReference(ReaderContext, token, table[i]));
}
return(result);
}
/// <inheritdoc />
protected override IList <IResourceEntry> GetEntries()
{
var result = new OwnedCollection <IResourceDirectory, IResourceEntry>(this);
// Optimisation, check for invalid resource directory offset, and prevention of self loop:
if (_namedEntries + _idEntries == 0 || _depth >= MaxDepth)
{
_context.BadImage($"Reached maximum recursion depth of {_depth} sub resource directories.");
return(result);
}
uint baseRva = _context.File.OptionalHeader
.GetDataDirectory(DataDirectoryIndex.ResourceDirectory)
.VirtualAddress;
// Create entries reader.
uint entryListSize = (uint)((_namedEntries + _idEntries) * ResourceDirectoryEntry.EntrySize);
if (!_context.File.TryCreateReaderAtRva(_entriesRva, entryListSize, out var entriesReader))
{
_context.BadImage("Resource directory contains an invalid entry table RVA and/or entry count.");
return(result);
}
for (int i = 0; i < _namedEntries + _idEntries; i++)
{
var rawEntry = new ResourceDirectoryEntry(_context, entriesReader);
// Note: Even if creating the directory reader fails, we still want to include the directory entry
// itself. In such a case, we expose the directory as an empty directory. This is why the
// following if statement does not dictate the creation of the data entry or not.
if (!_context.File.TryCreateReaderAtRva(baseRva + rawEntry.DataOrSubDirOffset, out var entryReader))
{
_context.BadImage($"Resource directory entry {i.ToString()} has an invalid data offset.");
}
result.Add(rawEntry.IsSubDirectory
? (IResourceEntry) new SerializedResourceDirectory(_context, rawEntry, entryReader, _depth + 1)
: new SerializedResourceData(_context, rawEntry, entryReader));
}
return(result);
}
/// <inheritdoc />
protected override IList <ExportedType> GetExportedTypes()
{
var result = new OwnedCollection <ModuleDefinition, ExportedType>(this);
var table = DotNetDirectory.Metadata
.GetStream <TablesStream>()
.GetTable(TableIndex.ExportedType);
for (int i = 0; i < table.Count; i++)
{
var token = new MetadataToken(TableIndex.ExportedType, (uint)i + 1);
if (_memberFactory.TryLookupMember(token, out var member) && member is ExportedType exportedType)
{
result.Add(exportedType);
}
}
return(result);
}
/// <inheritdoc />
protected override IList <TypeDefinition> GetTopLevelTypes()
{
EnsureTypeDefinitionTreeInitialized();
var types = new OwnedCollection <ModuleDefinition, TypeDefinition>(this);
var typeDefTable = DotNetDirectory
.Metadata
.GetStream <TablesStream>()
.GetTable <TypeDefinitionRow>(TableIndex.TypeDef);
for (int i = 0; i < typeDefTable.Count; i++)
{
uint rid = (uint)i + 1;
if (_typeDefTree.GetKey(rid) == 0)
{
var token = new MetadataToken(TableIndex.TypeDef, rid);
types.Add(_memberFactory.LookupTypeDefinition(token));
}
}
return(types);
}
