public void FromMetadataStream_NonZeroStart()
{
var stream = new MemoryStream();
stream.WriteByte(0xff);
stream.Write(PortablePdbs.DocumentsPdb, 0, PortablePdbs.DocumentsPdb.Length);
stream.WriteByte(0xff);
stream.WriteByte(0xff);
stream.Position = 1;
var PortablePdbReader1 = MetadataReaderProvider.FromMetadataStream(stream, MetadataStreamOptions.LeaveOpen, PortablePdbs.DocumentsPdb.Length);
Assert.Equal(PortablePdbs.DocumentsPdb.Length, PortablePdbReader1.GetMetadataReader().Block.Length);
var reader1 = PortablePdbReader1.GetMetadataReader();
Assert.Equal(13, reader1.Documents.Count);
stream.Position = 1;
var PortablePdbReader2 = MetadataReaderProvider.FromMetadataStream(stream, MetadataStreamOptions.LeaveOpen | MetadataStreamOptions.PrefetchMetadata, PortablePdbs.DocumentsPdb.Length);
Assert.Equal(PortablePdbs.DocumentsPdb.Length, PortablePdbReader2.GetMetadataReader().Block.Length);
var reader2 = PortablePdbReader2.GetMetadataReader();
Assert.Equal(13, reader2.Documents.Count);
}
public void FromMetadataStream1()
{
Assert.Throws <ArgumentNullException>(() => MetadataReaderProvider.FromMetadataStream(null, MetadataStreamOptions.Default));
var invalid = new MemoryStream(new byte[] { 1, 2, 3, 4 });
// the stream should not be disposed if the arguments are bad
Assert.Throws <ArgumentOutOfRangeException>(() => MetadataReaderProvider.FromMetadataStream(invalid, (MetadataStreamOptions)int.MaxValue));
Assert.True(invalid.CanRead);
// prefetching metadata doesn't create a reader yet, so no exception is thrown:
var badReader = MetadataReaderProvider.FromMetadataStream(invalid, MetadataStreamOptions.PrefetchMetadata | MetadataStreamOptions.LeaveOpen);
Assert.True(invalid.CanRead);
invalid.Position = 0;
Assert.Throws <BadImageFormatException>(() => badReader.GetMetadataReader());
// valid metadata:
var valid = new MemoryStream(PortablePdbs.DocumentsPdb);
var PortablePdbReader = MetadataReaderProvider.FromMetadataStream(valid, MetadataStreamOptions.Default);
Assert.True(valid.CanRead);
PortablePdbReader.Dispose();
Assert.False(valid.CanRead);
}
private static GenerationData ReadDelta(string metadataPath, string ilPathOpt)
{
byte[] ilDelta;
try
{
ilDelta = (ilPathOpt != null) ? File.ReadAllBytes(ilPathOpt) : null;
}
catch (Exception e)
{
Console.WriteLine($"Error reading '{ilPathOpt}': {e.Message}");
return(null);
}
MetadataReaderProvider mdProvider;
try
{
var stream = File.OpenRead(metadataPath);
if (!IsManagedMetadata(stream))
{
throw new NotSupportedException("File format not supported");
}
mdProvider = MetadataReaderProvider.FromMetadataStream(stream);
}
catch (Exception e)
{
Console.WriteLine($"Error reading '{metadataPath}': {e.Message}");
return(null);
}
return(new GenerationData(mdProvider, mdProvider.GetMetadataReader(), ilDelta: ilDelta));
}
public void Test_CanGetMetaDataProviderFromStreamForPdb()
{
string peFilePath = Path.GetFullPath("../../../../../artefacts/test_debug.pdb");
var file = File.OpenRead(peFilePath);
var mdProvider = MetadataReaderProvider.FromMetadataStream(file);
Assert.NotNull(mdProvider);
}
public void Test_CanGetEntrypointAdressTableStringFromPdb()
{
string peFilePath = Path.GetFullPath("../../../../../artefacts/test_debug.pdb");
var file = File.OpenRead(peFilePath);
var mdProvider = MetadataReaderProvider.FromMetadataStream(file);
var mdReader = mdProvider.GetMetadataReader();
var table = Helpers.Table(mdReader.DebugMetadataHeader.EntryPoint);
Assert.Equal("MethodDef", table);
}
public void Test_CanGetEntrypointAddressStringFromPdb()
{
string peFilePath = Path.GetFullPath("../../../../../artefacts/test_debug.pdb");
var file = File.OpenRead(peFilePath);
var mdProvider = MetadataReaderProvider.FromMetadataStream(file);
var mdReader = mdProvider.GetMetadataReader();
var address = Helpers.AddressString(mdReader, mdReader.DebugMetadataHeader.EntryPoint);
Assert.Equal("0x06000001", address);
}
private static GenerationData ReadFile(string path, bool embeddedPdb)
{
try
{
var generation = new GenerationData();
var stream = File.OpenRead(path);
if (IsPE(stream))
{
var peReader = new PEReader(stream);
generation.PEReaderOpt = peReader;
if (embeddedPdb)
{
var embeddedEntries = peReader.ReadDebugDirectory().Where(entry => entry.Type == DebugDirectoryEntryType.EmbeddedPortablePdb).ToArray();
if (embeddedEntries.Length == 0)
{
throw new InvalidDataException("No embedded pdb found");
}
if (embeddedEntries.Length > 1)
{
throw new InvalidDataException("Multiple entries in Debug Directory Table of type EmbeddedPortablePdb");
}
var provider = peReader.ReadEmbeddedPortablePdbDebugDirectoryData(embeddedEntries[0]);
generation.MetadataReader = provider.GetMetadataReader();
generation.MemoryOwner = provider;
}
else
{
generation.MetadataReader = peReader.GetMetadataReader();
generation.MemoryOwner = peReader;
}
}
else if (IsManagedMetadata(stream))
{
var mdProvider = MetadataReaderProvider.FromMetadataStream(stream);
generation.MetadataReader = mdProvider.GetMetadataReader();
generation.MemoryOwner = mdProvider;
}
else
{
throw new NotSupportedException("File format not supported");
}
return(generation);
}
catch (Exception e)
{
Console.WriteLine($"Error reading '{path}': {e.Message}");
return(null);
}
}
public bool EnC(byte[] meta, byte[] pdb)
{
var asmStream = new MemoryStream(meta);
MetadataReader asmMetadataReader = MetadataReaderProvider.FromMetadataStream(asmStream).GetMetadataReader();
var pdbStream = new MemoryStream(pdb);
MetadataReader pdbMetadataReader = MetadataReaderProvider.FromPortablePdbStream(pdbStream).GetMetadataReader();
enCMetadataReader.Add(asmMetadataReader);
enCMetadataReader.Add(pdbMetadataReader);
PopulateEnC(asmMetadataReader, pdbMetadataReader);
return(true);
}
/// <summary>
/// Opens metadata section of the assembly file produced by the compiler.
/// </summary>
/// <param name="prefetch">
/// True to prefetch all metadata from the assembly and close the underlying stream on return,
/// otherwise keeps the underlying stream open until the returned <see cref="MetadataReaderProvider"/> is disposed.
/// </param>
/// <returns>
/// Instance of <see cref="MetadataReaderProvider"/>, which owns the opened metadata and must be disposed once the caller is done reading the data,
/// or null if the assembly is not available.
/// </returns>
/// <exception cref="BadImageFormatException">Invalid format of the assembly data.</exception>
/// <exception cref="InvalidOperationException">The stream returned by <see cref="OpenAssemblyStreamChecked"/> does not support read and seek operations.</exception>
/// <exception cref="Exception">Error while reading assembly data.</exception>
public virtual MetadataReaderProvider OpenAssemblyMetadata(bool prefetch)
{
var peStream = OpenAssemblyStreamChecked();
if (peStream != null)
{
PEHeaders peHeaders;
using (var peReader = new PEReader(peStream, PEStreamOptions.LeaveOpen))
{
peHeaders = peReader.PEHeaders;
}
peStream.Position = peHeaders.MetadataStartOffset;
return(MetadataReaderProvider.FromMetadataStream(
peStream,
prefetch ? MetadataStreamOptions.PrefetchMetadata : MetadataStreamOptions.Default,
size: peHeaders.MetadataSize));
}
return(null);
}
public void GetMetadataReader_FromMetadataStream()
{
TestGetMetadataReader(MetadataReaderProvider.FromMetadataStream(new MemoryStream(BuildMetadataImage().ToArray())));
}
public void GetMetadataReader_EmptyStream()
{
var provider = MetadataReaderProvider.FromMetadataStream(new MemoryStream(), MetadataStreamOptions.PrefetchMetadata);
Assert.Throws <BadImageFormatException>(() => provider.GetMetadataReader());
}
public void FromMetadataStream2()
{
AssertExtensions.Throws <ArgumentException>("stream", () => MetadataReaderProvider.FromMetadataStream(new CustomAccessMemoryStream(canRead: false, canSeek: false, canWrite: false)));
AssertExtensions.Throws <ArgumentException>("stream", () => MetadataReaderProvider.FromMetadataStream(new CustomAccessMemoryStream(canRead: true, canSeek: false, canWrite: false)));
MetadataReaderProvider.FromMetadataStream(new CustomAccessMemoryStream(canRead: true, canSeek: true, canWrite: false));
}
public static MetadataReaderProvider GetMetadataReaderProviderFromFileStream(FileStream fileStream)
{
return(MetadataReaderProvider.FromMetadataStream(fileStream));
}
public void FromMetadataStream2()
{
Assert.Throws <ArgumentException>(() => MetadataReaderProvider.FromMetadataStream(new TestStream(canRead: false, canSeek: false, canWrite: false)));
Assert.Throws <ArgumentException>(() => MetadataReaderProvider.FromMetadataStream(new TestStream(canRead: true, canSeek: false, canWrite: false)));
MetadataReaderProvider.FromMetadataStream(new TestStream(canRead: true, canSeek: true, canWrite: false));
}