private string GetComObjectFullyQualifiedName(object o)
{
if (o == null)
{
throw new ArgumentNullException();
}
if (Marshal.IsComObject(o))
{
IDispatch dispatch = o as IDispatch;
if (dispatch != null)
{
ITypeLib typeLib = null;
ITypeInfo typeInfo = dispatch.GetTypeInfo(0, 0);
int index = 0;
typeInfo.GetContainingTypeLib(out typeLib, out index);
string typeLibName = Marshal.GetTypeLibName(typeLib);
string typeInfoName = Marshal.GetTypeInfoName(typeInfo);
return(String.Format("{0}.{1}", typeLibName, typeInfoName));
}
}
return(o.GetType().FullName);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Temporarily registers the specified file.
/// </summary>
/// <param name="fileName">Name of the file.</param>
/// <param name="registerInHklm"><c>true</c> to register in HKLM, <c>false</c> to
/// register in HKCU. Passing <c>false</c> has the same effect as calling
/// regsvr32 with parameter /i:user.</param>
/// <param name="registerTypeLib"><c>true</c> to also register tye type library.</param>
/// ------------------------------------------------------------------------------------
public bool Register(string fileName, bool registerInHklm, bool registerTypeLib)
{
SetDllDirectory(Path.GetDirectoryName(fileName));
ApiInvokeDllInstall(m_Log, fileName, true, registerInHklm);
try
{
if (registerInHklm && registerTypeLib)
{
ITypeLib typeLib = LoadTypeLib(fileName);
var registerResult = RegisterTypeLib(typeLib, fileName, null);
if (registerResult == 0)
{
m_Log.LogMessage(MessageImportance.Low, "Registered {0} with result {1}",
fileName, registerResult);
}
else
{
m_Log.LogWarning("Registering {0} failed with result {1}", fileName,
registerResult);
}
}
else
{
m_Log.LogMessage(MessageImportance.Low, "Registered {0}", fileName);
}
}
catch (Exception e)
{
m_Log.LogWarningFromException(e);
}
return(true);
}
public static string GetTypeLibPath(ITypeLib typeLibrary)
{
if (typeLibrary == null)
{
throw new Exceptions.NullParameterException(typeof(ComInterop), "GetTypeLibPath", "typeLibrary");
}
System.IntPtr ptr = System.IntPtr.Zero;
typeLibrary.GetLibAttr(out ptr);
try
{
Win32.TLIBATTR libAttr = (Win32.TLIBATTR)Marshal.PtrToStructure(ptr, typeof(Win32.TLIBATTR));
Debug.Assert(libAttr.guid != System.Guid.Empty, "libAttr.guid != Guid.Empty");
string path = string.Empty;
Win32.SafeNativeMethods.QueryPathOfRegTypeLib(ref libAttr.guid, libAttr.wMajorVerNum,
libAttr.wMinorVerNum, libAttr.lcid, ref path);
return(path);
}
finally
{
typeLibrary.ReleaseTLibAttr(ptr);
}
}
private static string GetManagedTypeLibName(ITypeLib typeLib)
{
var typeLib2 = typeLib as ITypeLib2;
if (typeLib2 != null)
{
// ReSharper disable EmptyGeneralCatchClause
try
{
var guid = managedNameGuid;
object data;
typeLib2.GetCustData(ref guid, out data);
var name = data as string;
if (name != null)
{
name = name.Trim();
if (name.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) || name.EndsWith(".exe", StringComparison.OrdinalIgnoreCase))
{
return(name.Substring(0, name.Length - 4));
}
return(name);
}
}
catch (Exception)
{
}
// ReSharper restore EmptyGeneralCatchClause
}
return(Marshal.GetTypeLibName(typeLib));
}
public IntPtr GetTypeLibAttr(ITypeLib typeLib)
{
IntPtr ret;
typeLib.GetLibAttr(out ret);
return(ret);
}
/*
* Method: ITypeLibImporterNotifySink.ResolveRef
*
* Implementation of ITypeLibImporterNotifySink.ResolveRef - this method is called by the NDP type lib converter
* to resolve dependencies.
* We should never return null here - it's not documented as the proper way of failing dependency resolution.
* Instead, we use an exception to abort the conversion process.
*/
Assembly ITypeLibImporterNotifySink.ResolveRef(object objTypeLib)
{
// get attributes for our dependent typelib
ITypeLib typeLib = (ITypeLib)objTypeLib;
ComReference.GetTypeLibAttrForTypeLib(ref typeLib, out TYPELIBATTR attr);
// call our callback to do the dirty work for us
if (!ResolverCallback.ResolveComClassicReference(attr, base.OutputDirectory, null, null, out ComReferenceWrapperInfo wrapperInfo))
{
if (!Silent)
{
Log.LogWarningWithCodeFromResources("ResolveComReference.FailedToResolveDependentComReference", attr.guid, attr.wMajorVerNum, attr.wMinorVerNum);
}
throw new ComReferenceResolutionException();
}
Debug.Assert(wrapperInfo.assembly != null, "Successfully resolved assembly cannot be null!");
if (wrapperInfo.assembly == null)
{
throw new ComReferenceResolutionException();
}
if (!Silent)
{
Log.LogMessageFromResources(MessageImportance.Low, "ResolveComReference.ResolvedDependentComReference",
attr.guid, attr.wMajorVerNum, attr.wMinorVerNum, wrapperInfo.path);
}
Debug.Assert(wrapperInfo.assembly != null, "Expected a non-null wrapperInfo.assembly. It should have been loaded in GenerateWrapper if it was going to be necessary.");
return(wrapperInfo.assembly);
}
private static string GetManagedTypeInfoName(ITypeInfo typeInfo, ITypeLib typeLib)
{
var typeInfo2 = typeInfo as ITypeInfo2;
if (typeInfo2 != null)
{
// ReSharper disable EmptyGeneralCatchClause
try
{
var guid = managedNameGuid;
object data;
typeInfo2.GetCustData(ref guid, out data);
var name = data as string;
if (name != null)
{
return(name.Trim());
}
}
catch (Exception)
{
}
// ReSharper restore EmptyGeneralCatchClause
}
return(GetManagedTypeLibName(typeLib) + "." + Marshal.GetTypeInfoName(typeInfo));
}
internal static AssemblyName GetAssemblyNameFromTypelib(object typeLib, string asmFileName, byte[] publicKey, StrongNameKeyPair keyPair, Version asmVersion, AssemblyNameFlags asmNameFlags)
{
string strName = null;
string strDocString = null;
int dwHelpContext = 0;
string strHelpFile = null;
ITypeLib typeLibrary = (ITypeLib)typeLib;
typeLibrary.GetDocumentation(-1, out strName, out strDocString, out dwHelpContext, out strHelpFile);
if (asmFileName == null)
{
asmFileName = strName;
}
else
{
string fileName = Path.GetFileName(asmFileName);
string extension = Path.GetExtension(asmFileName);
if (!".dll".Equals(extension, StringComparison.OrdinalIgnoreCase))
{
throw new ArgumentException(Environment.GetResourceString("Arg_InvalidFileExtension"));
}
asmFileName = fileName.Substring(0, fileName.Length - ".dll".Length);
}
if (asmVersion == null)
{
int num2;
int num3;
Marshal.GetTypeLibVersion(typeLibrary, out num2, out num3);
asmVersion = new Version(num2, num3, 0, 0);
}
AssemblyName name = new AssemblyName();
name.Init(asmFileName, publicKey, null, asmVersion, null, AssemblyHashAlgorithm.None, AssemblyVersionCompatibility.SameMachine, null, asmNameFlags, keyPair);
return(name);
}
private static void SetPIAAttributeOnAssembly(AssemblyBuilder asmBldr, object typeLib)
{
IntPtr nULL = Win32Native.NULL;
ITypeLib lib = (ITypeLib)typeLib;
int wMajorVerNum = 0;
int wMinorVerNum = 0;
Type[] types = new Type[] { typeof(int), typeof(int) };
ConstructorInfo constructor = typeof(PrimaryInteropAssemblyAttribute).GetConstructor(types);
try
{
lib.GetLibAttr(out nULL);
System.Runtime.InteropServices.ComTypes.TYPELIBATTR typelibattr = (System.Runtime.InteropServices.ComTypes.TYPELIBATTR)Marshal.PtrToStructure(nULL, typeof(System.Runtime.InteropServices.ComTypes.TYPELIBATTR));
wMajorVerNum = typelibattr.wMajorVerNum;
wMinorVerNum = typelibattr.wMinorVerNum;
}
finally
{
if (nULL != Win32Native.NULL)
{
lib.ReleaseTLibAttr(nULL);
}
}
object[] constructorArgs = new object[] { wMajorVerNum, wMinorVerNum };
CustomAttributeBuilder customBuilder = new CustomAttributeBuilder(constructor, constructorArgs);
asmBldr.SetCustomAttribute(customBuilder);
}
//private IEnumerable<string> GetImplementedInterfaceNames(TYPEATTR typeAttr, ITypeInfo info)
//{
// for (var implIndex = 0; implIndex < typeAttr.cImplTypes; implIndex++)
// {
// int href;
// info.GetRefTypeOfImplType(implIndex, out href);
// ITypeInfo implTypeInfo;
// info.GetRefTypeInfo(href, out implTypeInfo);
// var implTypeName = GetTypeName(implTypeInfo);
// yield return implTypeName;
// //Debug.WriteLine(string.Format("\tImplements {0}", implTypeName));
// }
//}
private DeclarationType GetDeclarationType(ITypeLib typeLibrary, int i)
{
TYPEKIND typeKind;
typeLibrary.GetTypeInfoType(i, out typeKind);
DeclarationType typeDeclarationType = DeclarationType.Control; // todo: a better default
if (typeKind == TYPEKIND.TKIND_ENUM)
{
typeDeclarationType = DeclarationType.Enumeration;
}
else if (typeKind == TYPEKIND.TKIND_COCLASS || typeKind == TYPEKIND.TKIND_INTERFACE ||
typeKind == TYPEKIND.TKIND_ALIAS || typeKind == TYPEKIND.TKIND_DISPATCH)
{
typeDeclarationType = DeclarationType.ClassModule;
}
else if (typeKind == TYPEKIND.TKIND_RECORD)
{
typeDeclarationType = DeclarationType.UserDefinedType;
}
else if (typeKind == TYPEKIND.TKIND_MODULE)
{
typeDeclarationType = DeclarationType.ProceduralModule;
}
return(typeDeclarationType);
}
internal static string GetMetadataName(string strSrcTypeLib, ITypeLib TypeLib, out string strMetaFileRoot)
{
string typeLibName = "";
strMetaFileRoot = "";
if (TypeLib == null)
{
TypeLib = GetTypeLib(strSrcTypeLib);
if (TypeLib == null)
{
return(typeLibName);
}
}
typeLibName = Marshal.GetTypeLibName(TypeLib);
strMetaFileRoot = typeLibName + ".dll";
char[] anyOf = new char[] { '/', '\\' };
int startIndex = strSrcTypeLib.LastIndexOfAny(anyOf) + 1;
if (startIndex <= 0)
{
startIndex = 0;
}
if (strSrcTypeLib.Substring(startIndex, strSrcTypeLib.Length - startIndex).ToLower(CultureInfo.InvariantCulture) == strMetaFileRoot.ToLower(CultureInfo.InvariantCulture))
{
typeLibName = typeLibName + "SoapLib";
strMetaFileRoot = typeLibName + ".dll";
}
return(typeLibName);
}
internal void AnalyzeTypeLibrary(ITypeLib typeLibrary)
{
try
{
int typeInfoCount = typeLibrary.GetTypeInfoCount();
for (int i = 0; i < typeInfoCount; i++)
{
ITypeInfo ppTI = null;
try
{
typeLibrary.GetTypeInfo(i, out ppTI);
this.AnalyzeTypeInfo(ppTI);
}
finally
{
if (ppTI != null)
{
this.marshalReleaseComObject(ppTI);
}
}
}
}
catch (COMException exception)
{
this.encounteredProblems.Add(exception);
}
}
private bool CanSkipType(ITypeInfo typeInfo, ITypeLib typeLib, System.Runtime.InteropServices.ComTypes.TYPEATTR typeAttributes, System.Runtime.InteropServices.ComTypes.TYPELIBATTR typeLibAttributes)
{
if (((typeAttributes.guid == Microsoft.Build.Tasks.NativeMethods.IID_IUnknown) || (typeAttributes.guid == Microsoft.Build.Tasks.NativeMethods.IID_IDispatch)) || (((typeAttributes.guid == Microsoft.Build.Tasks.NativeMethods.IID_IDispatchEx) || (typeAttributes.guid == Microsoft.Build.Tasks.NativeMethods.IID_IEnumVariant)) || (typeAttributes.guid == Microsoft.Build.Tasks.NativeMethods.IID_ITypeInfo)))
{
return(true);
}
if (typeLibAttributes.guid == Microsoft.Build.Tasks.NativeMethods.IID_StdOle)
{
string str;
string str2;
string str3;
int num;
typeInfo.GetDocumentation(-1, out str, out str2, out num, out str3);
if (string.CompareOrdinal(str, "GUID") == 0)
{
return(true);
}
}
ITypeLib2 lib = typeLib as ITypeLib2;
if (lib != null)
{
object obj2;
lib.GetCustData(ref Microsoft.Build.Tasks.NativeMethods.GUID_ExportedFromComPlus, out obj2);
string str4 = obj2 as string;
if (!string.IsNullOrEmpty(str4))
{
return(true);
}
}
return(false);
}
public ComStruct(ITypeLib typeLib, ITypeInfo info, TYPEATTR attrib, int index)
: base(typeLib, attrib, index)
{
_fields = new List <ComField>();
Type = DeclarationType.UserDefinedType;
GetFields(info, attrib);
}
public ComCoClass(ITypeLib typeLib, ITypeInfo info, TYPEATTR attrib, int index) : base(typeLib, attrib, index)
{
Type = DeclarationType.ClassModule;
GetImplementedInterfaces(info, attrib);
IsControl = attrib.wTypeFlags.HasFlag(TYPEFLAGS.TYPEFLAG_FCONTROL);
Debug.Assert(attrib.cFuncs == 0);
}
private static Assembly LoadPrimaryInteropAssembly(ITypeLib typeLib)
{
// ReSharper disable EmptyGeneralCatchClause
try
{
IntPtr pAttr;
typeLib.GetLibAttr(out pAttr);
try
{
var attr = (TYPELIBATTR)Marshal.PtrToStructure(pAttr, typeof(TYPELIBATTR));
string name;
string codeBase;
if (new TypeLibConverter().GetPrimaryInteropAssembly(attr.guid, attr.wMajorVerNum, attr.wMinorVerNum, attr.lcid, out name, out codeBase))
{
return(Assembly.Load(new AssemblyName(name)
{
CodeBase = codeBase
}));
}
}
finally
{
typeLib.ReleaseTLibAttr(pAttr);
}
}
catch (Exception)
{
}
return(null);
// ReSharper restore EmptyGeneralCatchClause
}
public IntPtr GetTypeLibAttr(ITypeLib typeLib)
{
if (typeLib == null) throw new ArgumentNullException(nameof(typeLib));
IntPtr ret;
typeLib.GetLibAttr(out ret);
return ret;
}
public static Type GetInteropType(this System.Object o)
{
if (o == null)
{
throw new ArgumentNullException();
}
if (Marshal.IsComObject(o))
{
IDispatch dispatch = o as IDispatch;
if (dispatch != null)
{
ITypeLib typeLib = null;
ITypeInfo typeInfo = dispatch.GetTypeInfo(0, 0);
int index = 0;
typeInfo.GetContainingTypeLib(out typeLib, out index);
string typeLibName = Marshal.GetTypeLibName(typeLib);
string typeInfoName = Marshal.GetTypeInfoName(typeInfo);
string typeFullName = String.Format("{0}.{1}", typeLibName, typeInfoName);
System.Reflection.Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
System.Reflection.Assembly assembly = assemblies.FirstOrDefault(x => x.GetType(typeFullName) != null);
if (assembly != null)
{
return(assembly.GetType(typeFullName));
}
}
}
return(o.GetType());
}
/// <summary>
/// Exports the type library of the given assembly, then registers
/// the type library. Will recursively export and register TLBs of
/// referenced assemblies as needed.
/// </summary>
/// <param name="assembly"><see cref="System.Reflection.Assembly"/>
/// to export. Cannot be <c>null</c>.</param>
/// <param name="typeLibName">Full path to type library to export.
/// Cannot be <c>null</c>, empty or equal to the path of
/// <paramref name="assembly"/>.</param>
/// <exception cref="ArgumentNullException"><paramref name="assembly"/>
/// or <paramref name="typeLibName"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException"><paramref name="typeLibName"/>
/// is <see cref="String.Empty"/>.
///
/// OR
///
/// <paramref name="typeLibName"/> is equal to the local path
/// of <paramref name="assembly"/>.</exception>
public void ExportAndRegisterTypeLibrary(Assembly assembly, string typeLibName)
{
// Validate input.
if (assembly == null)
{
throw new ArgumentNullException("assembly");
}
if (typeLibName == null)
{
throw new ArgumentNullException("typeLibName");
}
if (typeLibName.Length == 0)
{
throw new ArgumentException("Type library name cannot be empty.", "typeLibName");
}
string assemblyName = AssemblyTools.GetAssemblyPath(assembly);
if (String.Compare(assemblyName, typeLibName, true) == 0)
{
throw new ArgumentException("Type library cannot overwrite assembly.", "typeLibName");
}
// Export the type lib, then register it.
ITypeLib tlb = ExportTypeLibrary(assembly, typeLibName);
RegisterTypeLibrary(tlb, typeLibName);
// Log normal message to tell we've registered the type lib.
console.WriteLine("Type library \"{0}\" exported from assembly \"{1}\" " +
"and registered successfully.", assemblyName, typeLibName);
}
/*
* Method: GetTypeLibNameForTypeLibAttrs
*
* Gets the name of given type library.
*/
internal static bool GetTypeLibNameForTypeLibAttrs(TaskLoggingHelper log, bool silent, TYPELIBATTR typeLibAttr, out string typeLibName)
{
typeLibName = "";
ITypeLib typeLib = null;
try
{
// load our type library
try
{
TYPELIBATTR attr = typeLibAttr;
typeLib = (ITypeLib)NativeMethods.LoadRegTypeLib(ref attr.guid, attr.wMajorVerNum, attr.wMinorVerNum, attr.lcid);
}
catch (COMException ex)
{
if (!silent)
{
log.LogWarningWithCodeFromResources("ResolveComReference.CannotLoadTypeLib", typeLibAttr.guid, typeLibAttr.wMajorVerNum, typeLibAttr.wMinorVerNum, ex.Message);
}
return(false);
}
string typeLibId = log.FormatResourceString("ResolveComReference.TypeLibAttrId", typeLibAttr.guid.ToString(), typeLibAttr.wMajorVerNum, typeLibAttr.wMinorVerNum);
return(GetTypeLibNameForITypeLib(log, silent, typeLib, typeLibId, out typeLibName));
}
finally
{
if (typeLib != null)
{
Marshal.ReleaseComObject(typeLib);
}
}
}
internal void AnalyzeTypeLibrary(ITypeLib typeLibrary)
{
try
{
int typeInfoCount = typeLibrary.GetTypeInfoCount();
for (int i = 0; i < typeInfoCount; i++)
{
ITypeInfo ppTI = null;
try
{
typeLibrary.GetTypeInfo(i, out ppTI);
this.AnalyzeTypeInfo(ppTI);
}
finally
{
if (ppTI != null)
{
this.marshalReleaseComObject(ppTI);
}
}
}
}
catch (COMException exception)
{
this.encounteredProblems.Add(exception);
}
}
public Assembly Convert(ITypeLib tl)
{
tl.GetLibAttr(out IntPtr ipta);
var ta = *(_TYPELIBATTR *)ipta;
tl.ReleaseTLibAttr(ipta);
var hash = Fnv1((byte *)&ta, sizeof(_TYPELIBATTR) - 2).ToString("x");
tl.GetDocumentation(-1, out var tlName, out var tlDescription, out var _, out var _);
var fileName = $"{tlName} {ta.wMajorVerNum}.{ta.wMinorVerNum} #{hash}.dll";
var netPath = saveDir + fileName;
if (!s_converted.TryGetValue(fileName, out var asm) || !File.Exists(netPath))
{
Print($"Converted: {tlName} ({tlDescription}) to \"{fileName}\".");
var converter = new TypeLibConverter();
asm = converter.ConvertTypeLibToAssembly(tl, netPath,
TypeLibImporterFlags.ReflectionOnlyLoading | TypeLibImporterFlags.TransformDispRetVals | TypeLibImporterFlags.UnsafeInterfaces,
this, null, null, tlName, null);
asm.Save(fileName);
s_converted[fileName] = asm;
}
return(asm);
}
private static Assembly LoadPrimaryInteropAssembly(ITypeLib typeLib)
{
// ReSharper disable EmptyGeneralCatchClause
if (typeLib == null)
{
return(null);
}
try
{
using (var attrScope = typeLib.CreateAttrScope())
{
string name;
string codeBase;
if (GetPrimaryInteropAssembly(attrScope.Value.guid, attrScope.Value.wMajorVerNum, attrScope.Value.wMinorVerNum, out name, out codeBase))
{
return(Assembly.Load(new AssemblyName(name)
{
CodeBase = codeBase
}));
}
}
}
catch (Exception)
{
}
return(null);
// ReSharper restore EmptyGeneralCatchClause
}
internal static string GetMetadataName(string strSrcTypeLib, ITypeLib TypeLib, out string strMetaFileRoot)
{
string typeLibName = "";
strMetaFileRoot = "";
if (TypeLib == null)
{
TypeLib = GetTypeLib(strSrcTypeLib);
if (TypeLib == null)
{
return typeLibName;
}
}
typeLibName = Marshal.GetTypeLibName(TypeLib);
strMetaFileRoot = typeLibName + ".dll";
char[] anyOf = new char[] { '/', '\\' };
int startIndex = strSrcTypeLib.LastIndexOfAny(anyOf) + 1;
if (startIndex <= 0)
{
startIndex = 0;
}
if (strSrcTypeLib.Substring(startIndex, strSrcTypeLib.Length - startIndex).ToLower(CultureInfo.InvariantCulture) == strMetaFileRoot.ToLower(CultureInfo.InvariantCulture))
{
typeLibName = typeLibName + "SoapLib";
strMetaFileRoot = typeLibName + ".dll";
}
return typeLibName;
}
public void GetContainingTypeLib(out ITypeLib ppTLB, out int pIndex)
{
_faultInjector.FailurePointThrow(MockTypeLibrariesFailurePoints.ITypeInfo_GetContainingTypeLib);
ppTLB = _containingTypeLib;
pIndex = _indexInContainingTypeLib;
}
public TypeLibViewModel(ITypeLib typeLib)
{
_typeLib = typeLib;
TYPELIBATTR attr = COMUtil.GetTypeLibAttr(typeLib);
CLSID = attr.guid.ToString();
MajorVersion = attr.wMajorVerNum;
MinorVersion = attr.wMinorVerNum;
LCID = attr.lcid;
//Name = Marshal.GetTypeLibName(typeLib);
string name, docString, helpFile;
int helpContext;
typeLib.GetDocumentation(-1,
out name,
out docString,
out helpContext,
out helpFile);
Path = COMUtil.GetTypeLibPath(typeLib);
Name = name;
Description = docString;
// Remove the null char
HelpFilePath = helpFile == null ? string.Empty : helpFile.Substring(0, helpFile.Length - 1);
string asmName, asmCodeBase;
var converter = new TypeLibConverter();
converter.GetPrimaryInteropAssembly(
attr.guid, MajorVersion, MinorVersion, LCID, out asmName, out asmCodeBase);
PIAName = asmName;
PIACodeBase = asmCodeBase;
}
private static void SetPIAAttributeOnAssembly(AssemblyBuilder asmBldr, object typeLib)
{
IntPtr ppTLibAttr = IntPtr.Zero;
ITypeLib typeLib1 = (ITypeLib)typeLib;
int num1 = 0;
int num2 = 0;
ConstructorInfo constructor = typeof(PrimaryInteropAssemblyAttribute).GetConstructor(new Type[2] {
typeof(int), typeof(int)
});
try
{
typeLib1.GetLibAttr(out ppTLibAttr);
System.Runtime.InteropServices.ComTypes.TYPELIBATTR typelibattr = (System.Runtime.InteropServices.ComTypes.TYPELIBATTR)Marshal.PtrToStructure(ppTLibAttr, typeof(System.Runtime.InteropServices.ComTypes.TYPELIBATTR));
num1 = (int)typelibattr.wMajorVerNum;
num2 = (int)typelibattr.wMinorVerNum;
}
finally
{
if (ppTLibAttr != IntPtr.Zero)
{
typeLib1.ReleaseTLibAttr(ppTLibAttr);
}
}
object[] constructorArgs = new object[2] {
(object)num1, (object)num2
};
CustomAttributeBuilder customBuilder = new CustomAttributeBuilder(constructor, constructorArgs);
asmBldr.SetCustomAttribute(customBuilder);
}
/// <summary>
/// Attempts to load the specified type lib and return it's parsed metadata.
/// </summary>
/// <param name="typeLibPath"></param>
/// <returns></returns>
bool TryLoadTypeLibFromPathInternal(string path, out TypeLibInfo info)
{
info = null;
if (string.IsNullOrWhiteSpace(path))
{
return(false);
}
Log.LogMessage("TryLoadTypeLibFromPath: {0}", path);
ITypeLib typeLib = null;
var typeLibPtr = IntPtr.Zero;
try
{
typeLib = LoadTypeLib(path);
if (typeLib != null)
{
typeLib.GetLibAttr(out typeLibPtr);
if (typeLibPtr != IntPtr.Zero)
{
// marshal pointer into struct
var ta = (System.Runtime.InteropServices.ComTypes.TYPELIBATTR)Marshal.PtrToStructure(typeLibPtr, typeof(System.Runtime.InteropServices.ComTypes.TYPELIBATTR));
// obtain information from typelib
typeLib.GetDocumentation(-1, out var name, out var docString, out var helpContext, out var helpFile);
// generate information
info = new TypeLibInfo()
{
Name = name,
Description = docString,
Guid = ta.guid,
MajorVersion = ta.wMajorVerNum,
MinorVersion = ta.wMinorVerNum,
Lcid = ta.lcid,
TypeLibPath = NormalizePath(path),
TypeLibFilePath = GetTypeLibFilePath(path),
};
// success
return(true);
}
}
}
catch (COMException e)
{
Log.LogMessage(MessageImportance.Low, "LoadTypeLib error: {0}; {1}", path, e.Message);
}
finally
{
if (typeLib != null && typeLibPtr != IntPtr.Zero)
{
typeLib.ReleaseTLibAttr(typeLibPtr);
}
}
return(false);
}
/// <summary>
/// Resolves a reference during the exporting process. This means that the
/// type library references the type library in another assembly. We must
/// call back our <see cref="TypeLibHelper"/> to do this.
/// </summary>
/// <param name="assembly">Assembly to resolve.</param>
/// <returns>Type library for the specified <paramref name="assembly"/>.
/// Must implement the <see cref="ITypeLib"/> interface.</returns>
/// <exception cref="ArgumentNullException"><paramref name="assembly"/>
/// is <c>null</c>.</exception>
public object ResolveRef(Assembly assembly)
{
ITypeLib tlb = null;
// Validate input.
if (assembly == null)
{
throw new ArgumentNullException("assembly");
}
// We'll export the type lib next to the assembly.
string assemblyName = assembly.GetName().Name;
string typeLibName = Path.ChangeExtension(Path.Combine(Path.GetDirectoryName(
AssemblyTools.GetAssemblyPath(assembly)), assemblyName), ".tlb");
// Log recursive references in verbose mode.
parent.console.Verbose.WriteLine("Recursively exporting and registering type " +
"library of assembly \"{0}\" to \"{1}\".", assemblyName, typeLibName);
// Call back parent to export and register the type lib.
tlb = parent.ExportTypeLibrary(assembly, typeLibName);
parent.RegisterTypeLibrary(tlb, typeLibName);
Debug.Assert(tlb != null);
return(tlb);
}
/// <summary>
/// The main entry point to the dependency walker
/// </summary>
/// <param name="typeLibrary">type library to be analyzed</param>
internal void AnalyzeTypeLibrary(ITypeLib typeLibrary)
{
try
{
int typeInfoCount = typeLibrary.GetTypeInfoCount();
for (int i = 0; i < typeInfoCount; i++)
{
ITypeInfo typeInfo = null;
try
{
typeLibrary.GetTypeInfo(i, out typeInfo);
AnalyzeTypeInfo(typeInfo);
}
finally
{
if (typeInfo != null)
{
_marshalReleaseComObject(typeInfo);
}
}
}
}
// This is the only catch block in this class, meaning that once a type library throws it's game over for it.
// I've tried using a finer grained approach but experiments with COM objects on my machine have shown that if
// a type library is broken, it's broken in several places (e.g. dependencies on a type lib that's not
// registered properly). Trying to recover from errors and continue with scanning dependencies only meant
// that we got lots of exceptions thrown which was not only not very useful for the end user, but also horribly slow.
catch (COMException ex)
{
EncounteredProblems.Add(ex);
}
}
private void DisposeInternal()
{
if (m_typeLib != null)
{
Marshal.ReleaseComObject(m_typeLib);
m_typeLib = null;
}
}
internal TypeLibraryBrowserInfo(string filePath, ITypeLib typeLibrary, ComBrowserManager manager)
{
Debug.Assert(typeLibrary != null && manager != null, "typeLibrary != null && manager != null");
m_filePath = filePath;
m_typeLibrary = new ComLibWrapper(typeLibrary);
m_manager = manager;
}
public ComDocumentation(ITypeLib typeLib, int index)
{
typeLib.GetDocumentation(index, out string name, out string docString, out int helpContext, out string helpFile);
Name = name;
DocString = docString;
HelpContext = helpContext;
HelpFile = helpFile?.Trim('\0');
}
/// <summary>
/// Release the COM ITypeLib pointer for this reference
/// </summary>
internal void ReleaseTypeLibPtr()
{
if (typeLibPointer != null)
{
Marshal.ReleaseComObject(typeLibPointer);
typeLibPointer = null;
}
}
public static TYPELIBATTR GetTypeLibAttr(ITypeLib typeLib)
{
IntPtr ppTLibAttr;
typeLib.GetLibAttr(out ppTLibAttr);
TYPELIBATTR tlibattr = (TYPELIBATTR)Marshal.PtrToStructure(ppTLibAttr, typeof(TYPELIBATTR));
typeLib.ReleaseTLibAttr(ppTLibAttr);
return tlibattr;
}
public static IList<string> GetProgIds(ITypeLib typeLib)
{
var typeInfos = GetTypeInfos(typeLib);
return typeInfos
.Select(GetTypeAttr)
.Where(attr => attr.typekind == TYPEKIND.TKIND_COCLASS)
.Select(ProgIdFromTypeAttr)
.ToList();
}
internal ComReferenceInfo(ComReferenceInfo copyFrom)
{
this.attr = copyFrom.attr;
this.typeLibName = copyFrom.typeLibName;
this.typeLibPath = copyFrom.typeLibPath;
this.typeLibPointer = copyFrom.typeLibPointer;
this.primaryOfAxImpRef = copyFrom.primaryOfAxImpRef;
this.resolvedWrapper = copyFrom.resolvedWrapper;
this.taskItem = new TaskItem(copyFrom.taskItem);
this.dependentWrapperPaths = copyFrom.dependentWrapperPaths;
this.referencePathItem = copyFrom.referencePathItem;
}
public static ITypeInfo[] GetTypeInfos(ITypeLib typeLib)
{
var infoCount = typeLib.GetTypeInfoCount();
var infos = new ITypeInfo[infoCount];
for (int i = 0; i < infoCount; i++)
{
ITypeInfo info;
typeLib.GetTypeInfo(i, out info);
infos[i] = info;
}
return infos;
}
internal static Assembly GenerateAssemblyFromNativeTypeLibrary(Guid iid, Guid typeLibraryID, ITypeLib typeLibrary)
{
TypeLibraryHelper helper = GetHelperInstance();
try
{
return helper.GenerateAssemblyFromNativeTypeLibInternal(iid, typeLibraryID, typeLibrary);
}
finally
{
ReleaseHelperInstance();
}
}
public TypeViewModel(ITypeLib typeLib, int index)
{
Members = new List<MemberViewModel>();
ITypeInfo typeInfo;
typeLib.GetTypeInfo(index, out typeInfo);
string strName, strDocString, strHelpFile;
int dwHelpContext;
typeLib.GetDocumentation(index, out strName, out strDocString, out dwHelpContext, out strHelpFile);
Name = strName;
// This sometimes throws a COMException
var attr = COMUtil.GetTypeAttr(typeInfo);
Kind = attr.typekind;
// Get the functions
for (int i = 0; i < attr.cFuncs; i++)
{
// TODO: Figure out why this throws an AccessViolationException for the groove type library
IntPtr ppFuncDesc;
typeInfo.GetFuncDesc(i, out ppFuncDesc);
FUNCDESC funcdesc = (FUNCDESC)Marshal.PtrToStructure(ppFuncDesc, typeof(FUNCDESC));
typeInfo.ReleaseFuncDesc(ppFuncDesc);
typeInfo.GetDocumentation(funcdesc.memid, out strName, out strDocString, out dwHelpContext, out strHelpFile);
var member = new MemberViewModel(strName);
Members.Add(member);
}
// Get the vars
for (int i = 0; i < attr.cVars; i++)
{
IntPtr ppVarDesc;
typeInfo.GetVarDesc(i, out ppVarDesc);
VARDESC vardesc = (VARDESC)Marshal.PtrToStructure(ppVarDesc, typeof(VARDESC));
typeInfo.ReleaseVarDesc(ppVarDesc);
typeInfo.GetDocumentation(vardesc.memid, out strName, out strDocString, out dwHelpContext, out strHelpFile);
var member = new MemberViewModel(strName);
Members.Add(member);
}
}
internal bool InitializeWithPath(TaskLoggingHelper log, string path, ITaskItem originalTaskItem, string targetProcessorArchitecture)
{
Microsoft.Build.Shared.ErrorUtilities.VerifyThrowArgumentNull(path, "path");
this.taskItem = originalTaskItem;
this.typeLibPath = ComReference.StripTypeLibNumberFromPath(path, new Microsoft.Build.Shared.FileExists(File.Exists));
string str = targetProcessorArchitecture;
if (str != null)
{
if (!(str == "AMD64") && !(str == "IA64"))
{
if (str == "x86")
{
this.typeLibPointer = (ITypeLib) Microsoft.Build.Tasks.NativeMethods.LoadTypeLibEx(path, 0x20);
goto Label_00A2;
}
if (str == "MSIL")
{
}
}
else
{
this.typeLibPointer = (ITypeLib) Microsoft.Build.Tasks.NativeMethods.LoadTypeLibEx(path, 0x40);
goto Label_00A2;
}
}
this.typeLibPointer = (ITypeLib) Microsoft.Build.Tasks.NativeMethods.LoadTypeLibEx(path, 2);
Label_00A2:
try
{
ComReference.GetTypeLibAttrForTypeLib(ref this.typeLibPointer, out this.attr);
if (!ComReference.GetTypeLibNameForITypeLib(log, this.typeLibPointer, this.GetTypeLibId(log), out this.typeLibName))
{
this.ReleaseTypeLibPtr();
return false;
}
}
catch (COMException)
{
this.ReleaseTypeLibPtr();
throw;
}
return true;
}
public static string GetTypeLibPath(ITypeLib typeLib)
{
var attr = GetTypeLibAttr(typeLib);
return GetTypeLibPath(attr.guid, attr.wMajorVerNum, attr.wMinorVerNum, attr.lcid);
}
static extern int LoadTypeLibEx([MarshalAs(UnmanagedType.BStr)] string szFile, RegKind regkind, out ITypeLib pptlib);
static extern int LoadRegTypeLib( ref Guid rguid, short wVerMajor, short wVerMinor, int lcid, out ITypeLib pptlib);
public static string GetTypeLibName (ITypeLib typelib)
{
throw new NotImplementedException ();
}
internal static bool GetTypeLibNameForITypeLib(TaskLoggingHelper log, ITypeLib typeLib, string typeLibId, out string typeLibName)
{
typeLibName = "";
ITypeLib2 lib = typeLib as ITypeLib2;
if (lib == null)
{
typeLibName = Marshal.GetTypeLibName(typeLib);
return true;
}
try
{
object pVarVal = null;
lib.GetCustData(ref Microsoft.Build.Tasks.NativeMethods.GUID_TYPELIB_NAMESPACE, out pVarVal);
if ((pVarVal == null) || (string.Compare(pVarVal.GetType().ToString(), "system.string", StringComparison.OrdinalIgnoreCase) != 0))
{
typeLibName = Marshal.GetTypeLibName(typeLib);
return true;
}
typeLibName = (string) pVarVal;
if ((typeLibName.Length >= 4) && (string.Compare(typeLibName.Substring(typeLibName.Length - 4), ".dll", StringComparison.OrdinalIgnoreCase) == 0))
{
typeLibName = typeLibName.Substring(0, typeLibName.Length - 4);
}
}
catch (COMException exception)
{
log.LogWarningWithCodeFromResources("ResolveComReference.CannotAccessTypeLibName", new object[] { typeLibId, exception.Message });
typeLibName = Marshal.GetTypeLibName(typeLib);
return true;
}
return true;
}
private static extern void LoadTypeLibEx(string strTypeLibName, REGKIND regKind, out ITypeLib TypeLib);
private static Assembly ConvertTypeLibToAssembly(ITypeLib typeLib)
{
if (m_typelibs == null)
{
LoadTypeLibAssemblies();
}
if (m_typelibs.ContainsKey(Marshal.GetTypeLibGuid(typeLib)))
{
return m_typelibs[Marshal.GetTypeLibGuid(typeLib)];
}
else
{
string strAssemblyPath = GetTypeLibDirectory();
strAssemblyPath = Path.Combine(strAssemblyPath, Marshal.GetTypeLibName(typeLib) + ".dll");
TypeLibConverter conv = new TypeLibConverter();
AssemblyBuilder asm = conv.ConvertTypeLibToAssembly(typeLib, strAssemblyPath, TypeLibImporterFlags.ReflectionOnlyLoading,
new TypeLibCallback(), null, null, null, null);
asm.Save(Path.GetFileName(strAssemblyPath));
Assembly a = Assembly.LoadFile(strAssemblyPath);
m_typelibs[Marshal.GetTypeLibGuid(typeLib)] = a;
RegisterTypeInterfaces(a);
return a;
}
}
public static Guid GetTypeLibGuid(ITypeLib! typelib) {
CodeContract.Requires(typelib != null);
//
// Summary:
// Retrieves the library identifier (LIBID) of a type library.
//
// Parameters:
// pTLB:
// A System.Runtime.InteropServices.UCOMITypeLib that represents an ITypeLib
// pointer.
//
// Returns:
// The LIBID (that is, the System.Guid) of the type library pointed to by the
// pTLB parameter.
return default(Guid);
}
public static string GetTypeLibName(ITypeLib! typelib) {
CodeContract.Requires(typelib != null);
//
// Summary:
// Retrieves the name of a type library.
//
// Parameters:
// pTLB:
// A System.Runtime.InteropServices.UCOMITypeLib that represents an ITypeLib
// pointer.
//
// Returns:
// The name of the type library pointed to by the pTLB parameter.
return default(string);
}
private static extern int RegisterTypeLib(ITypeLib typeLib, string fullPath, string helpDir);
public static extern int LoadTypeLib(string szFile, out ITypeLib typeLib);
public static extern HRESULT LoadTypeLib([MarshalAs(UnmanagedType.LPWStr)] string fileName, out ITypeLib typeLib);
public TypeLib(ITypeLib typelib)
{
m_typelib = typelib;
m_typeLib2 = typelib as ITypeLib2;
}
public static unsafe extern int LoadTypeLib([MarshalAs(UnmanagedType.BStr)] string strFile, out ITypeLib ppTypeLib);
public void GetContainingTypeLib(out ITypeLib ppTLB, out int pIndex)
{
_faultInjector.FailurePointThrow(MockTypeLibrariesFailurePoints.ITypeInfo_GetContainingTypeLib);
ppTLB = _containingTypeLib;
pIndex = _indexInContainingTypeLib;
}
public static Guid GetTypeLibGuid (ITypeLib typelib)
{
throw new NotImplementedException ();
}
public static int GetTypeLibLcid (ITypeLib typelib)
{
throw new NotImplementedException ();
}
public void ReleaseTypeLibAttr(ITypeLib typeLib, IntPtr typeLibAttr)
{
if (typeLib == null) throw new ArgumentNullException(nameof(typeLib));
typeLib.ReleaseTLibAttr(typeLibAttr);
}
internal static void GetTypeLibAttrForTypeLib(ref ITypeLib typeLib, out System.Runtime.InteropServices.ComTypes.TYPELIBATTR typeLibAttr)
{
IntPtr zero = IntPtr.Zero;
typeLib.GetLibAttr(out zero);
if (zero == IntPtr.Zero)
{
throw new COMException(Microsoft.Build.Shared.ResourceUtilities.FormatResourceString("ResolveComReference.CannotGetTypeLibAttrForTypeLib", new object[0]));
}
try
{
typeLibAttr = (System.Runtime.InteropServices.ComTypes.TYPELIBATTR) Marshal.PtrToStructure(zero, typeof(System.Runtime.InteropServices.ComTypes.TYPELIBATTR));
}
finally
{
typeLib.ReleaseTLibAttr(zero);
}
}
