public static PdbSymbolReader TryOpenSymbolReaderForMetadataFile(string metadataFileName, string searchPath)
{
try
{
if (s_metadataDispenser == null || s_symBinder == null)
{
return(null);
}
Guid IID_IMetaDataImport = new Guid(0x7dac8207, 0xd3ae, 0x4c75, 0x9b, 0x67, 0x92, 0x80, 0x1a, 0x49, 0x7d, 0x44);
// Open an metadata importer on the given filename. We'll end up passing this importer straight
// through to the Binder.
object objImporter;
if (s_metadataDispenser.OpenScope(metadataFileName, 0x00000010 /* read only */, ref IID_IMetaDataImport, out objImporter) < 0)
{
return(null);
}
ISymUnmanagedReader reader;
if (s_symBinder.GetReaderForFile(objImporter, metadataFileName, searchPath, out reader) < 0)
{
return(null);
}
return(new UnmanagedPdbSymbolReader(reader));
}
catch
{
return(null);
}
}
public PdbSymbols GetSymbolsProviderForFile(string assemblyFile)
{
PdbSymbols reader;
if (!_readers.TryGetValue(assemblyFile, out reader))
{
ISymUnmanagedReader rawReader;
var importerIID = typeof(IMetaDataImport).GUID;
var importer = _dispenser.OpenScope(assemblyFile, 0, ref importerIID);
int result = _symbolBinder.GetReaderForFile2(importer,
assemblyFile,
Path.GetDirectoryName(assemblyFile),
SymSearchPolicies.AllowOriginalPathAccess,
out rawReader);
if (result == (int)DiaErrors.E_PDB_NOT_FOUND ||
result < 0)
{
return(null);
}
_readers.Add(assemblyFile, reader = new PdbSymbols(rawReader));
_instanceCollector.AddComObject(rawReader);
_instanceCollector.AddComObject(importer);
}
return(reader);
}
public static ISymbolWriter CreateWriter(string assembly, string pdb)
{
SymWriter writer = new SymWriter(false);
object objDispenser, objImporter;
CoCreateInstance(ref s_dispenserClassID, null, 1, ref s_dispenserIID, out objDispenser);
IMetaDataDispenser dispenser = (IMetaDataDispenser)objDispenser;
dispenser.OpenScope(assembly, 1, ref s_importerIID, out objImporter);
IntPtr importerPtr = Marshal.GetComInterfaceForObject(objImporter, typeof(IMetadataImport));
try {
if (File.Exists(pdb))
{
File.Delete(pdb);
}
writer.Initialize(importerPtr, pdb, false);
} finally {
if (importerPtr != IntPtr.Zero)
{
Marshal.Release(importerPtr);
Marshal.ReleaseComObject(objDispenser);
Marshal.ReleaseComObject(objImporter);
Marshal.ReleaseComObject(dispenser);
}
}
return(writer);
}
MetaDataReader(string moduleName)
{
CLRMetaHost mh = new CLRMetaHost();
CLRRuntimeInfo highestInstalledRuntime = null;
foreach (CLRRuntimeInfo runtime in mh.EnumerateInstalledRuntimes())
{
if (highestInstalledRuntime == null ||
string.Compare(highestInstalledRuntime.GetVersionString(), runtime.GetVersionString(), StringComparison.OrdinalIgnoreCase) < 0)
{
highestInstalledRuntime = runtime;
}
}
if (highestInstalledRuntime == null)
{
throw new ApplicationException("Could not enumerate .NET runtimes on the system.");
}
IMetaDataDispenser metaDataDispenser = highestInstalledRuntime.GetIMetaDataDispenser();
Guid IMetaDataImport2_Guid = Guid("7DAC8207-D3AE-4c75-9B67-92801A497D44");
object metaDataImportObj;
metaDataDispenser.OpenScope(moduleName, 0, ref IMetaDataImport2_Guid, out metaDataImportObj);
m_metaDataImport = metaDataImportObj as IMetadataImport2;
}
public PDBReader(string assemblyPath)
{
object metaDataImport = null;
IMetaDataDispenser dispenser = null;
try
{
Guid metaDataImportIID = new Guid(IMetaDataImportGuid);
dispenser = (IMetaDataDispenser)(new MetaDataDispenser());
dispenser.OpenScope(assemblyPath, 0, ref metaDataImportIID, out metaDataImport);
this.symReader = (ISymUnmanagedReader)(new CorSymReader_SxS());
this.symReader.Initialize(metaDataImport, assemblyPath, null, null);
}
finally
{
// Release COM objects so that files don't remain locked.
if (metaDataImport != null)
{
Marshal.ReleaseComObject(metaDataImport);
}
if (dispenser != null)
{
Marshal.ReleaseComObject(dispenser);
}
}
}
public static ISymbolReader CreateReader(string filename)
{
SymBinder binder = new SymBinder();
object objDispenser, objImporter;
CoCreateInstance(ref s_dispenserClassID, null, 1, ref s_dispenserIID, out objDispenser);
IMetaDataDispenser dispenser = (IMetaDataDispenser)objDispenser;
dispenser.OpenScope(filename, 0, ref s_importerIID, out objImporter);
IntPtr importerPtr = IntPtr.Zero;
ISymbolReader reader;
try {
importerPtr = Marshal.GetComInterfaceForObject(objImporter, typeof(IMetadataImport));
reader = binder.GetReader(importerPtr, filename, null);
} finally {
if (importerPtr != IntPtr.Zero)
{
Marshal.Release(importerPtr);
}
}
return(reader);
}
public MetaDataInfo(string assemblyName)
{
Guid guid = new Guid(((GuidAttribute)Attribute.GetCustomAttribute(typeof(IMetaDataImportInternalOnly), typeof(GuidAttribute), false)).Value);
IMetaDataDispenser corMetaDataDispenser = (IMetaDataDispenser)(new CorMetaDataDispenser());
this.importInterface = (IMetaDataImportInternalOnly)corMetaDataDispenser.OpenScope(assemblyName, 0, ref guid);
Marshal.ReleaseComObject(corMetaDataDispenser);
}
private const int GENMAN_ENUM_TOKEN_BUF_SIZE = 16; // 128 from genman seems too big.
/// <summary>
/// Construct an instance for a source file.
/// </summary>
/// <param name="sourceFile">The assembly.</param>
internal AssemblyInformation(string sourceFile)
{
// Extra checks for PInvoke-destined data.
ErrorUtilities.VerifyThrowArgumentNull(sourceFile, "sourceFile");
_sourceFile = sourceFile;
// Create the metadata dispenser and open scope on the source file.
_metadataDispenser = (IMetaDataDispenser)new CorMetaDataDispenser();
_assemblyImport = (IMetaDataAssemblyImport)_metadataDispenser.OpenScope(sourceFile, 0, ref s_importerGuid);
}
private MetadataReader(string path)
{
_path = path;
// Create the metadata dispenser and open scope on the source file.
_metaDispenser = (IMetaDataDispenser)new CorMetaDataDispenser();
object obj;
int hr = _metaDispenser.OpenScope(path, 0, ref s_importerGuid, out obj);
if (hr == 0)
_assemblyImport = (IMetaDataAssemblyImport)obj;
}
private const int GENMAN_ENUM_TOKEN_BUF_SIZE = 16; // 128 from genman seems too big.
/// <summary>
/// Construct an instance for a source file.
/// </summary>
/// <param name="sourceFile">The assembly.</param>
internal AssemblyInformation(string sourceFile)
{
// Extra checks for PInvoke-destined data.
ErrorUtilities.VerifyThrowArgumentNull(sourceFile, "sourceFile");
_sourceFile = sourceFile;
// Create the metadata dispenser and open scope on the source file.
_metadataDispenser = (IMetaDataDispenser) new CorMetaDataDispenser();
_assemblyImport = (IMetaDataAssemblyImport)_metadataDispenser.OpenScope(sourceFile, 0, ref s_importerGuid);
}
public static ISymbolReader CreateReader(string filename)
{
SymBinder binder;
object objImporter;
IMetaDataDispenser dispenser = InstantiateDispenser(out binder);
dispenser.OpenScope(filename, 0, ref s_importerIID, out objImporter);
return(InstantiateReader(binder, filename, objImporter));
}
public MetaDataInfo(string assemblyName)
{
// Get guid for IMetaDataImport
Guid guidIMetaDataImport = new Guid(((GuidAttribute)Attribute.GetCustomAttribute(typeof(IMetaDataImportInternalOnly), typeof(GuidAttribute), false)).Value);
// Get an IMetaDataImport for the assembly from a dispenser
IMetaDataDispenser dispenser = (IMetaDataDispenser) new CorMetaDataDispenser();
importInterface = (IMetaDataImportInternalOnly)dispenser.OpenScope(assemblyName, 0, ref guidIMetaDataImport);
Marshal.ReleaseComObject(dispenser);
}
public static ISymbolReader GetSymbolReaderForFile(
System.Diagnostics.SymbolStore.SymBinder binder, string pathModule, string searchPath)
{
// Guids for imported metadata interfaces.
Guid dispenserClassID = new Guid(0xe5cb7a31, 0x7512, 0x11d2, 0x89,
0xce, 0x00, 0x80, 0xc7, 0x92, 0xe5, 0xd8); // CLSID_CorMetaDataDispenser
Guid dispenserIID = new Guid(0x809c652e, 0x7396, 0x11d2, 0x97, 0x71,
0x00, 0xa0, 0xc9, 0xb4, 0xd5, 0x0c); // IID_IMetaDataDispenser
Guid importerIID = new Guid(0x7dac8207, 0xd3ae, 0x4c75, 0x9b, 0x67,
0x92, 0x80, 0x1a, 0x49, 0x7d, 0x44); // IID_IMetaDataImport
// First create the Metadata dispenser.
object objDispenser;
NativeMethods.CoCreateInstance(ref dispenserClassID, null, 1,
ref dispenserIID, out objDispenser);
// Now open an Importer on the given filename. We'll end up passing this importer
// straight through to the Binder.
object objImporter = null;
IMetaDataDispenser dispenser = (IMetaDataDispenser)objDispenser;
try
{
dispenser.OpenScope(pathModule, 0, ref importerIID, out objImporter);
}
catch
{
Console.WriteLine(" ERROR: Failed dispenser.OpenScope() - perhaps this app needs to be compiled in x86?");
return(null);
}
IntPtr importerPtr = IntPtr.Zero;
ISymbolReader reader;
try
{
// This will manually AddRef the underlying object, so we need to
// be very careful to Release it.
importerPtr = Marshal.GetComInterfaceForObject(objImporter,
typeof(IMetadataImport));
reader = binder.GetReader(importerPtr, pathModule, searchPath);
}
finally
{
if (importerPtr != IntPtr.Zero)
{
Marshal.Release(importerPtr);
}
}
return(reader);
}
private MetadataReader(string path)
{
_path = path;
// Create the metadata dispenser and open scope on the source file.
_metaDispenser = (IMetaDataDispenser) new CorMetaDataDispenser();
int hr = _metaDispenser.OpenScope(path, 0, ref s_importerGuid, out object obj);
if (hr == 0)
{
_assemblyImport = (IMetaDataAssemblyImport)obj;
}
}
private static ISymUnmanagedReader CreateSymbolReader(string filename, string searchPath, bool avoidLocks)
{
// Guids for imported metadata interfaces.
Guid CLSID_CorMetaDataDispenser = new Guid(0xe5cb7a31, 0x7512, 0x11d2, 0x89, 0xce, 0x00, 0x80, 0xc7, 0x92, 0xe5, 0xd8);
Guid IID_IMetaDataImport = new Guid(0x7dac8207, 0xd3ae, 0x4c75, 0x9b, 0x67, 0x92, 0x80, 0x1a, 0x49, 0x7d, 0x44);
Guid CLSID_CorSymBinder = new Guid("0A29FF9E-7F9C-4437-8B11-F424491E3931");
// First create the Metadata dispenser.
IMetaDataDispenser dispenser = (IMetaDataDispenser)Activator.CreateInstance(Type.GetTypeFromCLSID(CLSID_CorMetaDataDispenser));
IntPtr importer = IntPtr.Zero;
try
{
int errorCode = dispenser.OpenScope(filename, 0, ref IID_IMetaDataImport, out importer);
if (errorCode < 0)
{
if (errorCode == E_FAIL ||
errorCode == E_FILE_NOT_FOUND)
{
return(null);
}
Marshal.ThrowExceptionForHR(errorCode);
}
ISymUnmanagedBinder3 binder = (ISymUnmanagedBinder3)Activator.CreateInstance(Type.GetTypeFromCLSID(CLSID_CorSymBinder));
ISymUnmanagedReader reader;
errorCode = CreateSymbolReader(binder, importer, filename, searchPath, avoidLocks, out reader);
if (errorCode < 0)
{
if (errorCode == E_FAIL ||
errorCode == E_PDB_DEBUG_INFO_NOT_IN_PDB ||
errorCode == E_PDB_NO_DEBUG_INFO ||
errorCode == E_PDB_NOT_FOUND)
{
return(null);
}
Marshal.ThrowExceptionForHR(errorCode);
}
return(reader);
}
finally
{
if (importer != IntPtr.Zero)
{
Marshal.Release(importer);
}
}
}
private PdbSymbolProvider(string binaryFilePath, string pdbFilePath = "")
{
_binaryFilePath = binaryFilePath;
_pdbFilePath = pdbFilePath;
if (String.IsNullOrEmpty(_pdbFilePath))
{
_pdbFilePath = Path.ChangeExtension(binaryFilePath, ".pdb");
}
// Create a COM Metadata dispenser
Guid dispenserClassID = new Guid(0xe5cb7a31, 0x7512, 0x11d2, 0x89, 0xce, 0x00, 0x80, 0xc7, 0x92, 0xe5, 0xd8); // CLSID_CorMetaDataDispenser
Guid dispenserIID = new Guid(0x809c652e, 0x7396, 0x11d2, 0x97, 0x71, 0x00, 0xa0, 0xc9, 0xb4, 0xd5, 0x0c); // IID_IMetaDataDispenser
object objDispenser;
Marshal.ThrowExceptionForHR(NativeMethods.MetaDataGetDispenser(ref dispenserClassID, ref dispenserIID, out objDispenser));
_metadataDispenser = (IMetaDataDispenser)objDispenser;
// Create a symbol binder [?]
Guid symBinderClassID = new Guid(0x0A29FF9E, 0x7F9C, 0x4437, 0x8B, 0x11, 0xF4, 0x24, 0x49, 0x1E, 0x39, 0x31); // CLSID_CorSymBinder
Guid symBinderIID = new Guid(0xAA544d42, 0x28CB, 0x11d3, 0xbd, 0x22, 0x00, 0x00, 0xf8, 0x08, 0x49, 0xbd); // IID_ISymUnmanagedBinder
object objBinder;
if (NativeMethods.CoCreateInstance(ref symBinderClassID,
IntPtr.Zero, // pUnkOuter
1, // CLSCTX_INPROC_SERVER
ref symBinderIID,
out objBinder) < 0)
{
throw new InvalidComObjectException("PdbSymbolProvider unable to construct an ISymUnmanagedBinder.");
}
_symBinder = (ISymUnmanagedBinder)objBinder;
// Create a symbol reader
Guid importerIID = new Guid(0x7dac8207, 0xd3ae, 0x4c75, 0x9b, 0x67, 0x92, 0x80, 0x1a, 0x49, 0x7d, 0x44); // IID_IMetaDataImport
// Open an metadata importer on the given filename. We'll end up passing this importer straight
// through to the Binder.
object objImporter;
Marshal.ThrowExceptionForHR(_metadataDispenser.OpenScope(binaryFilePath, 0x00000010 /* read only */, ref importerIID, out objImporter));
string pdbFolderPath = Path.GetDirectoryName(pdbFilePath);
ISymUnmanagedReader reader;
Marshal.ThrowExceptionForHR(_symBinder.GetReaderForFile(objImporter, binaryFilePath, pdbFolderPath, out reader));
_symReader = reader;
// Create a source file map [if we can find the map file]
_sourceFileMap = SourceFileMap.Load(pdbFilePath);
}
static IMetaDataImport GetDataImport(string location)
{
var dispenser = new IMetaDataDispenser();
var metaDataImportGuid = typeof(IMetaDataImport).GUID;
object scope;
var hr = dispenser.OpenScope(location, 0, ref metaDataImportGuid, out scope);
AssertHresultIsZero(hr);
return (IMetaDataImport)scope;
}
/// <summary>
/// Creaters importer acccess to metadata for new version of assembly.
/// </summary>
/// <param name="fileName">URL to the new assembly.</param>
/// <returns>Importer access to metadata of the new assembly.</returns>
private IMetaDataImport createImporter(string fileName)
{
Object objDispenser, objImporter = null;
int hResult = NativeMethods.CoCreateInstance(ref dispenserClassID, null, 1, ref dispenserIID, out objDispenser);
if (hResult == 0)
{
IMetaDataDispenser dispenser = (IMetaDataDispenser)objDispenser;
dispenser.OpenScope(fileName, 0, ref importerIID, out objImporter);
newDispenser = dispenser;
}
return((IMetaDataImport)objImporter);
}
private static string[] PeVerify(byte[] peImage, int domainId, string assemblyPath, bool metadataOnly)
{
if (MonoHelpers.IsRunningOnMono())
{
// PEverify is currently unsupported on Mono hence return an empty
// set of messages
return(new string[0]);
}
lock (s_guard)
{
GCHandle pinned = GCHandle.Alloc(peImage, GCHandleType.Pinned);
try
{
IntPtr buffer = pinned.AddrOfPinnedObject();
ICLRValidator validator = (ICLRValidator)GetRuntimeInterfaceAsObject(s_clsIdClrRuntimeHost, typeof(ICLRRuntimeHost).GUID);
ValidationErrorHandler errorHandler = new ValidationErrorHandler(validator);
IMetaDataDispenser dispenser = (IMetaDataDispenser)GetRuntimeInterfaceAsObject(s_clsIdCorMetaDataDispenser, typeof(IMetaDataDispenser).GUID);
// the buffer needs to be pinned during validation
Guid riid = typeof(IMetaDataImport).GUID;
object metaDataImport = null;
if (assemblyPath != null)
{
dispenser.OpenScope(assemblyPath, CorOpenFlags.ofRead, ref riid, out metaDataImport);
}
else
{
dispenser.OpenScopeOnMemory(buffer, (uint)peImage.Length, CorOpenFlags.ofRead, ref riid, out metaDataImport);
}
IMetaDataValidate metaDataValidate = (IMetaDataValidate)metaDataImport;
metaDataValidate.ValidatorInit(CorValidatorModuleType.ValidatorModuleTypePE, errorHandler);
metaDataValidate.ValidateMetaData();
if (!metadataOnly)
{
validator.Validate(errorHandler, (uint)domainId, ValidatorFlags.VALIDATOR_EXTRA_VERBOSE,
ulMaxError: 10, token: 0, fileName: assemblyPath, pe: buffer, ulSize: (uint)peImage.Length);
}
return(errorHandler.GetOutput());
}
finally
{
pinned.Free();
}
}
}
private static ISymbolReader TryGetSymbolReaderForFile(
SymBinder binder, string pathModule, string searchPath)
{
ISymbolReader reader;
IMetaDataDispenser dispenser = null;
IMetaDataImportStub importer = null;
var importerPtr = IntPtr.Zero;
try
{
// ReSharper disable once SuspiciousTypeConversion.Global
dispenser = (IMetaDataDispenser) new CorMetaDataDispenser();
var importerGuid = new Guid(InterfaceMetaDataImportGuid);
importer = (IMetaDataImportStub)dispenser.OpenScope(pathModule, 0, ref importerGuid);
// This will manually AddRef the underlying object, so we need to
// be very careful to Release it.
importerPtr = Marshal.GetComInterfaceForObject(importer, typeof(IMetaDataImportStub));
try
{
reader = binder.GetReader(importerPtr, pathModule, searchPath);
}
catch (COMException)
{
reader = null;
}
}
finally
{
if (importerPtr != IntPtr.Zero)
{
Marshal.Release(importerPtr);
}
if (importer != null)
{
Marshal.ReleaseComObject(importer);
}
if (dispenser != null)
{
Marshal.ReleaseComObject(dispenser);
}
}
return(reader);
}
/// <summary>
/// Construct an instance for a source file.
/// </summary>
/// <param name="sourceFile">The assembly.</param>
internal AssemblyInformation(string sourceFile)
{
// Extra checks for PInvoke-destined data.
ErrorUtilities.VerifyThrowArgumentNull(sourceFile, "sourceFile");
_sourceFile = sourceFile;
#if FEATURE_ASSEMBLY_LOADFROM
if (NativeMethodsShared.IsWindows)
{
// Create the metadata dispenser and open scope on the source file.
_metadataDispenser = (IMetaDataDispenser) new CorMetaDataDispenser();
_assemblyImport = (IMetaDataAssemblyImport)_metadataDispenser.OpenScope(sourceFile, 0, ref s_importerGuid);
}
else
{
_assembly = Assembly.ReflectionOnlyLoadFrom(sourceFile);
}
#endif
}
private static string[] PeVerify(byte[] peImage, int domainId, string assemblyPath)
{
lock (Guard)
{
GCHandle pinned = GCHandle.Alloc(peImage, GCHandleType.Pinned);
try
{
IntPtr buffer = pinned.AddrOfPinnedObject();
ICLRValidator validator = (ICLRValidator)RuntimeEnvironment.GetRuntimeInterfaceAsObject(ClsIdClrRuntimeHost, typeof(ICLRRuntimeHost).GUID);
ValidationErrorHandler errorHandler = new ValidationErrorHandler(validator);
IMetaDataDispenser dispenser = (IMetaDataDispenser)RuntimeEnvironment.GetRuntimeInterfaceAsObject(ClsIdCorMetaDataDispenser, typeof(IMetaDataDispenser).GUID);
// the buffer needs to be pinned during validation
Guid riid = typeof(IMetaDataImport).GUID;
object metaDataImport = null;
if (assemblyPath != null)
{
dispenser.OpenScope(assemblyPath, CorOpenFlags.ofRead, ref riid, out metaDataImport);
}
else
{
dispenser.OpenScopeOnMemory(buffer, (uint)peImage.Length, CorOpenFlags.ofRead, ref riid, out metaDataImport);
}
IMetaDataValidate metaDataValidate = (IMetaDataValidate)metaDataImport;
metaDataValidate.ValidatorInit(CorValidatorModuleType.ValidatorModuleTypePE, errorHandler);
metaDataValidate.ValidateMetaData();
validator.Validate(errorHandler, (uint)domainId, ValidatorFlags.VALIDATOR_EXTRA_VERBOSE,
ulMaxError: 10, token: 0, fileName: assemblyPath, pe: buffer, ulSize: (uint)peImage.Length);
return(errorHandler.GetOutput());
}
finally
{
pinned.Free();
}
}
}
public static ISymbolReader GetSymbolReader(SymBinder binder, string pathModule)
{
try
{
object objDispenser;
CoCreateInstance(ref CLSID_CorMetaDataDispenser,
null,
1,
ref IID_IMetaDataDispenser,
out objDispenser);
object objImporter;
IMetaDataDispenser dispenser = (IMetaDataDispenser)objDispenser;
dispenser.OpenScope(pathModule, 0, ref IID_IMetaDataImport, out objImporter);
IntPtr importerPtr = IntPtr.Zero;
ISymbolReader reader;
try
{
importerPtr = Marshal.GetComInterfaceForObject(objImporter, typeof(IMetadataImport));
reader = binder.GetReader(importerPtr, pathModule, null);
}
finally
{
if (importerPtr != IntPtr.Zero)
{
Marshal.Release(importerPtr);
}
}
return(reader);
}
catch (Exception)
{
return(null);
}
}
public ISymUnmanagedReader GetSymbolReaderForFile(string metadataFileName)
{
if (!File.Exists(Path.ChangeExtension(metadataFileName, ".pdb")))
{
return(null);
}
if (_metadataDispenser == null || _symBinder == null)
{
return(null);
}
try
{
Guid importerIID = new Guid(0x7dac8207, 0xd3ae, 0x4c75, 0x9b, 0x67, 0x92, 0x80, 0x1a, 0x49, 0x7d, 0x44); // IID_IMetaDataImport
// Open an metadata importer on the given filename. We'll end up passing this importer straight
// through to the Binder.
object objImporter;
if (_metadataDispenser.OpenScope(metadataFileName, 0x00000010 /* read only */, ref importerIID, out objImporter) < 0)
{
return(null);
}
ISymUnmanagedReader reader;
if (_symBinder.GetReaderForFile(objImporter, metadataFileName, "", out reader) < 0)
{
return(null);
}
return(reader);
}
catch
{
return(null);
}
}