internal override bool FindExistingWrapper(out ComReferenceWrapperInfo wrapperInfo, DateTime componentTimestamp)
{
if (!this.HasTemporaryWrapper)
{
return base.FindExistingWrapper(out wrapperInfo, componentTimestamp);
}
wrapperInfo = null;
return false;
}
internal override bool FindExistingWrapper(out ComReferenceWrapperInfo wrapperInfo, DateTime componentTimestamp)
{
if (!this.HasTemporaryWrapper)
{
return(base.FindExistingWrapper(out wrapperInfo, componentTimestamp));
}
wrapperInfo = null;
return(false);
}
/*
* Method: FindExistingWrapper
*
* Checks if there's a preexisting wrapper for this reference.
*/
internal override bool FindExistingWrapper(out ComReferenceWrapperInfo wrapperInfo, DateTime componentTimestamp)
{
if (!HasTemporaryWrapper)
{
return(base.FindExistingWrapper(out wrapperInfo, componentTimestamp));
}
// if this reference has a temporary wrapper, it can't possibly have a preexisting one
wrapperInfo = null;
return(false);
}
internal override bool FindExistingWrapper(out ComReferenceWrapperInfo wrapperInfo, DateTime componentTimestamp)
{
wrapperInfo = null;
string wrapperPath = this.GetWrapperPath();
if (!File.Exists(wrapperPath))
{
return false;
}
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = wrapperPath;
return this.IsWrapperUpToDate(wrapperInfo, componentTimestamp);
}
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;
}
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;
}
/*
* Method: GenerateWrapper
*
* Generates a wrapper for this reference.
*/
internal bool GenerateWrapper(out ComReferenceWrapperInfo wrapperInfo)
{
wrapperInfo = null;
// The tool gets the public key for itself, but we get it here anyway to
// give nice messages in errors cases.
StrongNameKeyPair keyPair = null;
byte[] publicKey = null;
GetAndValidateStrongNameKey(out keyPair, out publicKey);
bool generateWrapperSucceeded = true;
string tlbName = ReferenceInfo.taskItem.GetMetadata(ComReferenceItemMetadataNames.tlbReferenceName);
// Generate wrapper out-of-proc using aximp.exe from the target framework. MUST
// HAVE SET SDKTOOLSPATH TO THE TARGET SDK TO WORK
var axImp = new ResolveComReference.AxImp();
if (ReferenceInfo != null)
{
axImp.ActiveXControlName = ReferenceInfo.strippedTypeLibPath;
}
axImp.BuildEngine = BuildEngine;
axImp.ToolPath = ToolPath;
axImp.EnvironmentVariables = EnvironmentVariables;
axImp.DelaySign = DelaySign;
axImp.GenerateSource = false;
axImp.KeyContainer = KeyContainer;
axImp.KeyFile = KeyFile;
axImp.Silent = Silent;
if (ReferenceInfo != null && ReferenceInfo.primaryOfAxImpRef != null && ReferenceInfo.primaryOfAxImpRef.resolvedWrapper != null && ReferenceInfo.primaryOfAxImpRef.resolvedWrapper.path != null)
{
// This path should hit unless there was a prior resolution error or bug in the resolution code.
// The reason is that everything (tlbs and pias) gets resolved before AxImp references.
axImp.RuntimeCallableWrapperAssembly = ReferenceInfo.primaryOfAxImpRef.resolvedWrapper.path;
}
axImp.OutputAssembly = Path.Combine(OutputDirectory, GetWrapperFileName());
generateWrapperSucceeded = axImp.Execute();
string wrapperPath = GetWrapperPath();
// store the wrapper info...
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = wrapperPath;
wrapperInfo.assembly = Assembly.UnsafeLoadFrom(wrapperInfo.path);
// ...and we're done!
return(generateWrapperSucceeded);
}
/// <summary>
/// Compare the strong name signing state of the existing wrapper to the signing
/// state we are requesting in this run of the task. Return true if they match (e.g.
/// from a signing perspective, the wrapper is up-to-date) or false otherwise.
/// </summary>
private bool SigningRequirementsMatchExistingWrapper(ComReferenceWrapperInfo wrapperInfo)
{
StrongNameLevel desiredStrongNameLevel = StrongNameLevel.None;
if (!string.IsNullOrEmpty(KeyFile) || !string.IsNullOrEmpty(KeyContainer))
{
desiredStrongNameLevel = DelaySign ? StrongNameLevel.DelaySigned : StrongNameLevel.FullySigned;
}
// ...and see what we have already
StrongNameLevel currentStrongNameLevel = StrongNameUtils.GetAssemblyStrongNameLevel(wrapperInfo.path);
// if not matching, need to regenerate wrapper
if (desiredStrongNameLevel != currentStrongNameLevel)
{
return(false);
}
// if the wrapper needs a strong name, see if the public keys match
if (desiredStrongNameLevel == StrongNameLevel.DelaySigned ||
desiredStrongNameLevel == StrongNameLevel.FullySigned)
{
// get desired public key
StrongNameUtils.GetStrongNameKey(Log, KeyFile, KeyContainer, out _, out byte[] desiredPublicKey);
// get current public key
AssemblyName assemblyName = AssemblyName.GetAssemblyName(wrapperInfo.path);
if (assemblyName == null)
{
return(false);
}
byte[] currentPublicKey = assemblyName.GetPublicKey();
if (currentPublicKey.Length != desiredPublicKey.Length)
{
return(false);
}
// compare public keys byte by byte
for (int i = 0; i < currentPublicKey.Length; i++)
{
if (currentPublicKey[i] != desiredPublicKey[i])
{
return(false);
}
}
}
return(true);
}
internal override bool FindExistingWrapper(out ComReferenceWrapperInfo wrapperInfo, DateTime componentTimestamp)
{
wrapperInfo = null;
string wrapperPath = this.GetWrapperPath();
if (!File.Exists(wrapperPath))
{
return(false);
}
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = wrapperPath;
return(this.IsWrapperUpToDate(wrapperInfo, componentTimestamp));
}
/*
* Method: GenerateWrapper
*
* Generates a wrapper for this reference.
*/
internal bool GenerateWrapper(out ComReferenceWrapperInfo wrapperInfo)
{
wrapperInfo = null;
// The tool gets the public key for itself, but we get it here anyway to
// give nice messages in errors cases.
StrongNameKeyPair keyPair = null;
byte[] publicKey = null;
GetAndValidateStrongNameKey(out keyPair, out publicKey);
bool generateWrapperSucceeded = true;
string tlbName = ReferenceInfo.taskItem.GetMetadata(ComReferenceItemMetadataNames.tlbReferenceName);
// Generate wrapper out-of-proc using aximp.exe from the target framework. MUST
// HAVE SET SDKTOOLSPATH TO THE TARGET SDK TO WORK
var axImp = new ResolveComReference.AxImp();
axImp.ActiveXControlName = ReferenceInfo.strippedTypeLibPath;
axImp.BuildEngine = BuildEngine;
axImp.ToolPath = ToolPath;
axImp.EnvironmentVariables = EnvironmentVariables;
axImp.DelaySign = DelaySign;
axImp.GenerateSource = false;
axImp.KeyContainer = KeyContainer;
axImp.KeyFile = KeyFile;
axImp.Silent = Silent;
if (ReferenceInfo != null && ReferenceInfo.primaryOfAxImpRef != null && ReferenceInfo.primaryOfAxImpRef.resolvedWrapper != null && ReferenceInfo.primaryOfAxImpRef.resolvedWrapper.path != null)
{
// This path should hit unless there was a prior resolution error or bug in the resolution code.
// The reason is that everything (tlbs and pias) gets resolved before AxImp references.
axImp.RuntimeCallableWrapperAssembly = ReferenceInfo.primaryOfAxImpRef.resolvedWrapper.path;
}
axImp.OutputAssembly = Path.Combine(OutputDirectory, GetWrapperFileName());
generateWrapperSucceeded = axImp.Execute();
string wrapperPath = GetWrapperPath();
// store the wrapper info...
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = wrapperPath;
wrapperInfo.assembly = Assembly.UnsafeLoadFrom(wrapperInfo.path);
// ...and we're done!
return generateWrapperSucceeded;
}
/*
* Method: FindExistingWrapper
*
* Checks if there's a preexisting wrapper for this reference.
*/
internal override bool FindExistingWrapper(out ComReferenceWrapperInfo wrapperInfo, DateTime componentTimestamp)
{
wrapperInfo = null;
string wrapperPath = GetWrapperPath();
// now see if the wrapper assembly actually exists
if (!File.Exists(wrapperPath))
{
return(false);
}
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = wrapperPath;
return(IsWrapperUpToDate(wrapperInfo, componentTimestamp));
}
internal bool GenerateWrapper(out ComReferenceWrapperInfo wrapperInfo)
{
wrapperInfo = null;
StrongNameKeyPair keyPair = null;
byte[] publicKey = null;
StrongNameUtils.GetStrongNameKey(base.Log, base.KeyFile, base.KeyContainer, out keyPair, out publicKey);
if (!base.DelaySign && (keyPair == null))
{
if ((base.KeyContainer != null) && (base.KeyContainer.Length > 0))
{
base.Log.LogErrorWithCodeFromResources(null, this.ReferenceInfo.SourceItemSpec, 0, 0, 0, 0, "ResolveComReference.StrongNameUtils.NoKeyPairInContainer", new object[] { base.KeyContainer });
throw new StrongNameException();
}
if ((base.KeyFile != null) && (base.KeyFile.Length > 0))
{
base.Log.LogErrorWithCodeFromResources(null, this.ReferenceInfo.SourceItemSpec, 0, 0, 0, 0, "ResolveComReference.StrongNameUtils.NoKeyPairInFile", new object[] { base.KeyFile });
throw new StrongNameException();
}
}
bool flag = true;
this.ReferenceInfo.taskItem.GetMetadata("TlbReferenceName");
ResolveComReference.AxImp imp = new ResolveComReference.AxImp {
ActiveXControlName = this.ReferenceInfo.typeLibPath,
BuildEngine = base.BuildEngine,
ToolPath = base.ToolPath,
EnvironmentVariables = base.EnvironmentVariables,
DelaySign = base.DelaySign,
GenerateSource = false,
KeyContainer = base.KeyContainer,
KeyFile = base.KeyFile
};
if (((this.ReferenceInfo != null) && (this.ReferenceInfo.primaryOfAxImpRef != null)) && ((this.ReferenceInfo.primaryOfAxImpRef.resolvedWrapper != null) && (this.ReferenceInfo.primaryOfAxImpRef.resolvedWrapper.path != null)))
{
imp.RuntimeCallableWrapperAssembly = this.ReferenceInfo.primaryOfAxImpRef.resolvedWrapper.path;
}
imp.OutputAssembly = Path.Combine(this.OutputDirectory, base.GetWrapperFileName());
flag = imp.Execute();
string wrapperPath = base.GetWrapperPath();
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = wrapperPath;
wrapperInfo.assembly = Assembly.UnsafeLoadFrom(wrapperInfo.path);
return(flag);
}
/// <summary>
/// Checks if the existing wrapper is up to date.
/// </summary>
protected virtual bool IsWrapperUpToDate(ComReferenceWrapperInfo wrapperInfo, DateTime componentTimestamp)
{
Debug.Assert(!string.IsNullOrEmpty(ReferenceInfo.strippedTypeLibPath), "ReferenceInfo.path should be valid if we got here");
if (string.IsNullOrEmpty(ReferenceInfo.strippedTypeLibPath))
{
throw new ComReferenceResolutionException();
}
// if wrapper doesn't exist, wrapper is obviously not up to date
if (!FileSystems.Default.FileExists(wrapperInfo.path))
{
return(false);
}
// if typelib file has a DIFFERENT last write time, wrapper is not up to date
// the reason we're comparing write times in an unusual way is that type libraries are unusual
// "source files" for wrappers. If you upgrade/downgrade a system component, its write
// time may be earlier than before but we should still regenerate the wrapper.
if (DateTime.Compare(File.GetLastWriteTime(ReferenceInfo.strippedTypeLibPath), componentTimestamp) != 0)
{
return(false);
}
// Compare our the existing wrapper's strong name state to the one we are requesting.
if (!SigningRequirementsMatchExistingWrapper(wrapperInfo))
{
return(false);
}
// ok, everything's looking fine, now just verify the assembly file is valid
try
{
wrapperInfo.assembly = Assembly.UnsafeLoadFrom(wrapperInfo.path);
}
catch (BadImageFormatException)
{
// ouch, this assembly is malformed... need to regenerate the wrapper.
wrapperInfo.assembly = null;
}
return(wrapperInfo.assembly != null);
}
internal override bool FindExistingWrapper(out ComReferenceWrapperInfo wrapperInfo, DateTime componentTimestamp)
{
string str;
string str2;
wrapperInfo = null;
TypeLibConverter converter = new TypeLibConverter();
if (!converter.GetPrimaryInteropAssembly(this.ReferenceInfo.attr.guid, this.ReferenceInfo.attr.wMajorVerNum, this.ReferenceInfo.attr.wMinorVerNum, this.ReferenceInfo.attr.lcid, out str, out str2))
{
return(false);
}
try
{
if ((str2 != null) && (str2.Length > 0))
{
Uri uri = new Uri(str2);
Assembly assembly = Assembly.UnsafeLoadFrom(uri.LocalPath);
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = uri.LocalPath;
wrapperInfo.assembly = assembly;
wrapperInfo.originalPiaName = new AssemblyNameExtension(AssemblyName.GetAssemblyName(uri.LocalPath));
}
else
{
Assembly assembly2 = Assembly.Load(str);
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = assembly2.Location;
wrapperInfo.assembly = assembly2;
wrapperInfo.originalPiaName = new AssemblyNameExtension(str, true);
}
}
catch (FileNotFoundException)
{
}
catch (BadImageFormatException)
{
base.Log.LogWarningWithCodeFromResources("ResolveComReference.BadAssemblyImage", new object[] { str });
}
return(wrapperInfo != null);
}
bool IComReferenceResolver.ResolveComClassicReference(System.Runtime.InteropServices.ComTypes.TYPELIBATTR typeLibAttr, string outputDirectory, string wrapperType, string refName, out ComReferenceWrapperInfo wrapperInfo)
{
ComReferenceInfo info;
bool topLevelRef = false;
wrapperInfo = null;
System.Runtime.InteropServices.ComTypes.TYPELIBATTR typelibattr = typeLibAttr;
if (ComReference.RemapAdoTypeLib(base.Log, ref typeLibAttr))
{
base.Log.LogMessageFromResources(MessageImportance.Low, "ResolveComReference.RemappingAdoTypeLib", new object[] { typelibattr.wMajorVerNum, typelibattr.wMinorVerNum });
}
if (this.IsExistingProjectReference(typeLibAttr, wrapperType, out info))
{
topLevelRef = true;
wrapperType = info.taskItem.GetMetadata("WrapperTool");
}
else if (this.IsExistingDependencyReference(typeLibAttr, out info))
{
if ((wrapperType == null) || ComReferenceTypes.IsPiaOrTlbImp(wrapperType))
{
string key = ComReference.UniqueKeyFromTypeLibAttr(typeLibAttr);
if (this.cachePia.ContainsKey(key))
{
wrapperType = "primary";
}
else if (this.cacheTlb.ContainsKey(key))
{
wrapperType = "tlbimp";
}
}
}
else
{
try
{
info = new ComReferenceInfo();
if (info.InitializeWithTypeLibAttrs(base.Log, typeLibAttr, null, this.TargetProcessorArchitecture))
{
this.allDependencyRefs.Add(info);
}
else
{
info.ReleaseTypeLibPtr();
return false;
}
}
catch (COMException exception)
{
base.Log.LogWarningWithCodeFromResources("ResolveComReference.CannotLoadTypeLib", new object[] { typeLibAttr.guid, typeLibAttr.wMajorVerNum.ToString(CultureInfo.InvariantCulture), typeLibAttr.wMinorVerNum.ToString(CultureInfo.InvariantCulture), exception.Message });
info.ReleaseTypeLibPtr();
return false;
}
}
if (refName == null)
{
refName = info.typeLibName;
}
return this.ResolveComClassicReference(info, outputDirectory, wrapperType, refName, topLevelRef, info.dependentWrapperPaths, out wrapperInfo);
}
/*
* Method: GenerateWrapper
*
* Generates a wrapper for this reference.
*/
internal bool GenerateWrapper(out ComReferenceWrapperInfo wrapperInfo)
{
wrapperInfo = null;
string rootNamespace = ReferenceInfo.typeLibName;
string wrapperPath = GetWrapperPath();
bool generateWrapperSucceeded = true;
if (ExecuteAsTool)
{
// delegate generation of the assembly to an instance of the TlbImp ToolTask. MUST
// HAVE SET SDKTOOLSPATH TO THE TARGET SDK TO WORK
var tlbImp = new ResolveComReference.TlbImp();
tlbImp.BuildEngine = BuildEngine;
tlbImp.EnvironmentVariables = EnvironmentVariables;
tlbImp.DelaySign = DelaySign;
tlbImp.KeyContainer = KeyContainer;
tlbImp.KeyFile = KeyFile;
tlbImp.OutputAssembly = wrapperPath;
tlbImp.ToolPath = ToolPath;
tlbImp.TypeLibName = ReferenceInfo.fullTypeLibPath;
tlbImp.AssemblyNamespace = rootNamespace;
tlbImp.AssemblyVersion = null;
tlbImp.PreventClassMembers = _noClassMembers;
tlbImp.SafeArrayAsSystemArray = true;
tlbImp.Silent = Silent;
tlbImp.Transform = ResolveComReference.TlbImpTransformFlags.TransformDispRetVals;
if (_referenceFiles != null)
{
// Issue is that there may be reference dependencies that need to be passed in. It is possible
// that the set of references will also contain the file that is meant to be written here (when reference resolution
// found the file in the output folder). We need to filter out this case.
var fullPathToOutput = Path.GetFullPath(wrapperPath); // Current directory is the directory of the project file.
tlbImp.ReferenceFiles = _referenceFiles.Where(rf => String.Compare(fullPathToOutput, rf, StringComparison.OrdinalIgnoreCase) != 0).ToArray();
}
switch (_targetProcessorArchitecture)
{
case UtilitiesProcessorArchitecture.MSIL:
tlbImp.Machine = "Agnostic";
break;
case UtilitiesProcessorArchitecture.AMD64:
tlbImp.Machine = "X64";
break;
case UtilitiesProcessorArchitecture.IA64:
tlbImp.Machine = "Itanium";
break;
case UtilitiesProcessorArchitecture.X86:
tlbImp.Machine = "X86";
break;
case UtilitiesProcessorArchitecture.ARM:
tlbImp.Machine = "ARM";
break;
case null:
break;
default:
// Transmit the flag directly from the .targets files and rely on tlbimp.exe to produce a good error message.
tlbImp.Machine = _targetProcessorArchitecture;
break;
}
generateWrapperSucceeded = tlbImp.Execute();
// store the wrapper info...
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = (HasTemporaryWrapper) ? null : wrapperPath;
// Changed to ReflectionOnlyLoadFrom, related to bug:
// RCR: Bad COM-interop assemblies being generated when using 64-bit MSBuild to build a project that is targeting 32-bit platform
// The original call to UnsafeLoadFrom loads the assembly in preparation for execution. If the assembly is x86 and this is x64 msbuild.exe then we
// have problems (UnsafeLoadFrom will fail). We only use this assembly for reference resolution so we don't need to be ready to execute the code.
//
// Its actually not clear to me that we even need to load the assembly at all. Reference resoluton is only used in the !ExecuteAsTool which is not
// where we are right now.
//
// If we really do need to load it then:
//
// wrapperInfo.assembly = Assembly.ReflectionOnlyLoadFrom(wrapperPath);
}
else
{
// use framework classes in-proc to generate the assembly
TypeLibConverter converter = new TypeLibConverter();
AssemblyBuilder assemblyBuilder = null;
StrongNameKeyPair keyPair;
byte[] publicKey;
GetAndValidateStrongNameKey(out keyPair, out publicKey);
try
{
TypeLibImporterFlags flags = TypeLibImporterFlags.SafeArrayAsSystemArray | TypeLibImporterFlags.TransformDispRetVals;
if (_noClassMembers)
{
flags |= TypeLibImporterFlags.PreventClassMembers;
}
switch (_targetProcessorArchitecture)
{
case UtilitiesProcessorArchitecture.MSIL:
flags |= TypeLibImporterFlags.ImportAsAgnostic;
break;
case UtilitiesProcessorArchitecture.AMD64:
flags |= TypeLibImporterFlags.ImportAsX64;
break;
case UtilitiesProcessorArchitecture.IA64:
flags |= TypeLibImporterFlags.ImportAsItanium;
break;
case UtilitiesProcessorArchitecture.X86:
flags |= TypeLibImporterFlags.ImportAsX86;
break;
case UtilitiesProcessorArchitecture.ARM:
flags |= TypeLibImporterFlags.ImportAsArm;
break;
default:
// Let the type importer decide.
break;
}
// Start the conversion process. We'll get callbacks on ITypeLibImporterNotifySink to resolve dependent refs.
assemblyBuilder = converter.ConvertTypeLibToAssembly(ReferenceInfo.typeLibPointer, wrapperPath,
flags, this, publicKey, keyPair, rootNamespace, null);
}
catch (COMException ex)
{
if (!Silent)
{
Log.LogWarningWithCodeFromResources("ResolveComReference.ErrorCreatingWrapperAssembly", ItemName, ex.Message);
}
throw new ComReferenceResolutionException(ex);
}
// if we're done, and this is not a temporary wrapper, write it out to disk
if (!HasTemporaryWrapper)
{
WriteWrapperToDisk(assemblyBuilder, wrapperPath);
}
// store the wrapper info...
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = (HasTemporaryWrapper) ? null : wrapperPath;
wrapperInfo.assembly = assemblyBuilder;
}
// ...and we're done!
return generateWrapperSucceeded;
}
/// <summary>
/// Helper function - resolves an ActiveX reference given the type library attributes.
/// </summary>
/// <param name="referenceInfo">Information about the reference to be resolved</param>
/// <param name="outputDirectory">Directory the interop DLL should be written to</param>
/// <param name="refName">Name of reference</param>
/// <param name="wrapperInfo">Information about wrapper locations</param>
/// <returns>True if the reference was already found or successfully generated, false otherwise.</returns>
internal bool ResolveComReferenceAx(ComReferenceInfo referenceInfo, string outputDirectory, string refName, out ComReferenceWrapperInfo wrapperInfo)
{
wrapperInfo = null;
string typeLibKey = ComReference.UniqueKeyFromTypeLibAttr(referenceInfo.attr);
// look in the Ax cache first
if (_cacheAx.ContainsKey(typeLibKey))
{
wrapperInfo = (ComReferenceWrapperInfo)_cacheAx[typeLibKey];
return true;
}
try
{
// not in the cache? see if anyone was kind enough to generate it for us
AxReference reference = new AxReference(Log, Silent, this, referenceInfo, refName, outputDirectory, DelaySign, KeyFile, KeyContainer, IncludeVersionInInteropName, _aximpPath, BuildEngine, EnvironmentVariables);
// wrapper doesn't exist or needs regeneration? generate it then
if (!reference.FindExistingWrapper(out wrapperInfo, _timestampCache[referenceInfo.strippedTypeLibPath]))
{
if (!reference.GenerateWrapper(out wrapperInfo))
return false;
}
// if found or successfully generated, cache it.
_cacheAx.Add(typeLibKey, wrapperInfo);
}
catch (Exception e) when (ExceptionHandling.IsIoRelatedException(e))
{
return false;
}
return true;
}
/// <summary> /// Finds an existing wrapper for the specified component /// </summary> internal abstract bool FindExistingWrapper(out ComReferenceWrapperInfo wrapperInfo, DateTime componentTimestamp);
/*
* Method: FindExistingWrapper
*
* Checks if there's a preexisting wrapper for this reference.
*/
internal override bool FindExistingWrapper(out ComReferenceWrapperInfo wrapperInfo, DateTime componentTimestamp)
{
if (!HasTemporaryWrapper)
{
return base.FindExistingWrapper(out wrapperInfo, componentTimestamp);
}
// if this reference has a temporary wrapper, it can't possibly have a preexisting one
wrapperInfo = null;
return false;
}
/*
* Method: Resolve
*
* Gets the resolved assembly path for the typelib wrapper.
*/
internal override bool FindExistingWrapper(out ComReferenceWrapperInfo wrapperInfo, DateTime componentTimestamp)
{
wrapperInfo = null;
// Let NDP do the dirty work...
TypeLibConverter converter = new TypeLibConverter();
string asmName, asmCodeBase;
if (!converter.GetPrimaryInteropAssembly(ReferenceInfo.attr.guid, ReferenceInfo.attr.wMajorVerNum, ReferenceInfo.attr.wMinorVerNum, ReferenceInfo.attr.lcid,
out asmName, out asmCodeBase))
{
return(false);
}
// let's try to load the assembly to determine its path and if it's there
try
{
if (asmCodeBase != null && asmCodeBase.Length > 0)
{
Uri uri = new Uri(asmCodeBase);
// make sure the PIA can be loaded
Assembly assembly = Assembly.UnsafeLoadFrom(uri.LocalPath);
// got here? then assembly must have been loaded successfully.
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = uri.LocalPath;
wrapperInfo.assembly = assembly;
// We need to remember the original assembly name of this PIA in case it gets redirected to a newer
// version and other COM components use that name to reference the PIA. assembly.FullName wouldn't
// work here since we'd get the redirected assembly name.
wrapperInfo.originalPiaName = new AssemblyNameExtension(AssemblyName.GetAssemblyName(uri.LocalPath));
}
else
{
Assembly assembly = Assembly.Load(asmName);
// got here? then assembly must have been loaded successfully.
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = assembly.Location;
wrapperInfo.assembly = assembly;
// We need to remember the original assembly name of this PIA in case it gets redirected to a newer
// version and other COM components use that name to reference the PIA.
wrapperInfo.originalPiaName = new AssemblyNameExtension(asmName, true);
}
}
catch (FileNotFoundException)
{
// This means that assembly file cannot be found.
// We don't need to do anything here; wrapperInfo is not set
// and we'll assume that the assembly doesn't exist.
}
catch (BadImageFormatException)
{
// Similar case as above, except we should additionally warn the user that the assembly file
// is not really a valid assembly file.
if (!Silent)
{
Log.LogWarningWithCodeFromResources("ResolveComReference.BadAssemblyImage", asmName);
}
}
// have we found the wrapper?
if (wrapperInfo != null)
{
return(true);
}
return(false);
}
/// <summary>
/// Helper function - resolves a regular tlb COM classic reference given the type library attributes.
/// </summary>
/// <param name="referenceInfo">Information about the reference to be resolved</param>
/// <param name="outputDirectory">Directory the interop DLL should be written to</param>
/// <param name="refName">Name of reference</param>
/// <param name="topLevelRef">True if this is a top-level reference</param>
/// <param name="wrapperInfo">Information about wrapper locations</param>
/// <returns>True if the reference was already found or successfully generated, false otherwise.</returns>
internal bool ResolveComReferenceTlb(ComReferenceInfo referenceInfo, string outputDirectory, string refName, bool topLevelRef, List<string> dependencyPaths, out ComReferenceWrapperInfo wrapperInfo)
{
wrapperInfo = null;
string typeLibKey = ComReference.UniqueKeyFromTypeLibAttr(referenceInfo.attr);
// look in the TLB cache first
if (_cacheTlb.ContainsKey(typeLibKey))
{
wrapperInfo = (ComReferenceWrapperInfo)_cacheTlb[typeLibKey];
return true;
}
// is it a temporary wrapper?
bool isTemporary = false;
// no top level (included in the project) refs can have temporary wrappers
if (!topLevelRef)
{
// wrapper is temporary if there's a top level tlb reference with the same typelib name, but different attributes
foreach (ComReferenceInfo projectRefInfo in allProjectRefs)
{
if (ComReferenceTypes.IsTlbImp(projectRefInfo.taskItem.GetMetadata(ComReferenceItemMetadataNames.wrapperTool)))
{
// conflicting typelib names for different typelibs? generate a temporary wrapper
if (!ComReference.AreTypeLibAttrEqual(referenceInfo.attr, projectRefInfo.attr) &&
String.Compare(referenceInfo.typeLibName, projectRefInfo.typeLibName, StringComparison.OrdinalIgnoreCase) == 0)
{
isTemporary = true;
}
}
}
}
try
{
List<string> referencePaths = new List<string>(GetResolvedAssemblyReferenceItemSpecs());
if (dependencyPaths != null)
{
referencePaths.AddRange(dependencyPaths);
}
// not in the cache? see if anyone was kind enough to generate it for us
TlbReference reference = new TlbReference(Log, Silent, this, referencePaths, referenceInfo, refName,
outputDirectory, isTemporary, DelaySign, KeyFile, KeyContainer, this.NoClassMembers,
this.TargetProcessorArchitecture, IncludeVersionInInteropName, ExecuteAsTool, _tlbimpPath,
BuildEngine, EnvironmentVariables);
// wrapper doesn't exist or needs regeneration? generate it then
if (!reference.FindExistingWrapper(out wrapperInfo, _timestampCache[referenceInfo.strippedTypeLibPath]))
{
if (!reference.GenerateWrapper(out wrapperInfo))
return false;
}
// if found or successfully generated, cache it.
_cacheTlb.Add(typeLibKey, wrapperInfo);
}
catch (Exception e) when (ExceptionHandling.IsIoRelatedException(e))
{
return false;
}
return true;
}
internal bool ResolveComReferencePia(ComReferenceInfo referenceInfo, string refName, out ComReferenceWrapperInfo wrapperInfo)
{
wrapperInfo = null;
string key = ComReference.UniqueKeyFromTypeLibAttr(referenceInfo.attr);
if (this.cachePia.ContainsKey(key))
{
wrapperInfo = (ComReferenceWrapperInfo) this.cachePia[key];
return true;
}
try
{
PiaReference reference = new PiaReference(base.Log, referenceInfo, refName);
if (!reference.FindExistingWrapper(out wrapperInfo, this.timestampCache[referenceInfo.typeLibPath]))
{
return false;
}
this.cachePia.Add(key, wrapperInfo);
}
catch (Exception exception)
{
if (Microsoft.Build.Shared.ExceptionHandling.NotExpectedException(exception))
{
throw;
}
return false;
}
return true;
}
protected virtual bool IsWrapperUpToDate(ComReferenceWrapperInfo wrapperInfo, DateTime componentTimestamp)
{
if ((this.ReferenceInfo.typeLibPath == null) || (this.ReferenceInfo.typeLibPath.Length == 0))
{
throw new ComReferenceResolutionException();
}
if (!File.Exists(wrapperInfo.path))
{
return(false);
}
if (DateTime.Compare(File.GetLastWriteTime(this.ReferenceInfo.typeLibPath), componentTimestamp) != 0)
{
return(false);
}
StrongNameLevel none = StrongNameLevel.None;
if (((this.KeyFile != null) && (this.KeyFile.Length > 0)) || ((this.KeyContainer != null) && (this.KeyContainer.Length > 0)))
{
if (this.DelaySign)
{
none = StrongNameLevel.DelaySigned;
}
else
{
none = StrongNameLevel.FullySigned;
}
}
StrongNameLevel assemblyStrongNameLevel = StrongNameUtils.GetAssemblyStrongNameLevel(wrapperInfo.path);
if (none != assemblyStrongNameLevel)
{
return(false);
}
if ((none == StrongNameLevel.DelaySigned) || (none == StrongNameLevel.FullySigned))
{
StrongNameKeyPair pair;
byte[] publicKey = null;
StrongNameUtils.GetStrongNameKey(base.Log, this.KeyFile, this.KeyContainer, out pair, out publicKey);
AssemblyName assemblyName = AssemblyName.GetAssemblyName(wrapperInfo.path);
if (assemblyName == null)
{
return(false);
}
byte[] buffer2 = assemblyName.GetPublicKey();
if (buffer2.Length != publicKey.Length)
{
return(false);
}
for (int i = 0; i < buffer2.Length; i++)
{
if (buffer2[i] != publicKey[i])
{
return(false);
}
}
}
try
{
wrapperInfo.assembly = Assembly.UnsafeLoadFrom(wrapperInfo.path);
}
catch (BadImageFormatException)
{
wrapperInfo.assembly = null;
}
return(wrapperInfo.assembly != null);
}
/// <summary>
/// Compare the strong name signing state of the existing wrapper to the signing
/// state we are requesting in this run of the task. Return true if they match (e.g.
/// from a signing perspective, the wrapper is up-to-date) or false otherwise.
/// </summary>
private bool SigningRequirementsMatchExistingWrapper(ComReferenceWrapperInfo wrapperInfo)
{
StrongNameLevel desiredStrongNameLevel = StrongNameLevel.None;
if ((KeyFile != null && KeyFile.Length > 0) || (KeyContainer != null && KeyContainer.Length > 0))
{
if (DelaySign)
{
desiredStrongNameLevel = StrongNameLevel.DelaySigned;
}
else
{
desiredStrongNameLevel = StrongNameLevel.FullySigned;
}
}
// ...and see what we have already
StrongNameLevel currentStrongNameLevel = StrongNameUtils.GetAssemblyStrongNameLevel(wrapperInfo.path);
// if not matching, need to regenerate wrapper
if (desiredStrongNameLevel != currentStrongNameLevel)
{
return false;
}
// if the wrapper needs a strong name, see if the public keys match
if (desiredStrongNameLevel == StrongNameLevel.DelaySigned ||
desiredStrongNameLevel == StrongNameLevel.FullySigned)
{
StrongNameKeyPair snkPair;
byte[] desiredPublicKey = null;
// get desired public key
StrongNameUtils.GetStrongNameKey(Log, KeyFile, KeyContainer, out snkPair, out desiredPublicKey);
// get current public key
AssemblyName assemblyName = AssemblyName.GetAssemblyName(wrapperInfo.path);
if (assemblyName == null)
{
return false;
}
byte[] currentPublicKey = assemblyName.GetPublicKey();
if (currentPublicKey.Length != desiredPublicKey.Length)
{
return false;
}
// compare public keys byte by byte
for (int i = 0; i < currentPublicKey.Length; i++)
{
if (currentPublicKey[i] != desiredPublicKey[i])
{
return false;
}
}
}
return true;
}
internal bool ResolveComClassicReference(ComReferenceInfo referenceInfo, string outputDirectory, string wrapperType, string refName, bool topLevelRef, List<string> dependencyPaths, out ComReferenceWrapperInfo wrapperInfo)
{
wrapperInfo = null;
bool flag = false;
if (ComReferenceTypes.IsPia(wrapperType))
{
flag = this.ResolveComReferencePia(referenceInfo, refName, out wrapperInfo);
}
else if (ComReferenceTypes.IsTlbImp(wrapperType))
{
flag = this.ResolveComReferenceTlb(referenceInfo, outputDirectory, refName, topLevelRef, dependencyPaths, out wrapperInfo);
}
else if (ComReferenceTypes.IsAxImp(wrapperType))
{
flag = this.ResolveComReferenceAx(referenceInfo, outputDirectory, refName, out wrapperInfo);
}
else if ((wrapperType == null) || ComReferenceTypes.IsPiaOrTlbImp(wrapperType))
{
flag = this.ResolveComReferencePia(referenceInfo, refName, out wrapperInfo);
if (!flag)
{
flag = this.ResolveComReferenceTlb(referenceInfo, outputDirectory, refName, false, dependencyPaths, out wrapperInfo);
}
}
else
{
Microsoft.Build.Shared.ErrorUtilities.VerifyThrow(false, "Unknown wrapper type!");
}
referenceInfo.resolvedWrapper = wrapperInfo;
this.timestampCache[referenceInfo.typeLibPath] = File.GetLastWriteTime(referenceInfo.typeLibPath);
return flag;
}
protected virtual bool IsWrapperUpToDate(ComReferenceWrapperInfo wrapperInfo, DateTime componentTimestamp)
{
if ((this.ReferenceInfo.typeLibPath == null) || (this.ReferenceInfo.typeLibPath.Length == 0))
{
throw new ComReferenceResolutionException();
}
if (!File.Exists(wrapperInfo.path))
{
return false;
}
if (DateTime.Compare(File.GetLastWriteTime(this.ReferenceInfo.typeLibPath), componentTimestamp) != 0)
{
return false;
}
StrongNameLevel none = StrongNameLevel.None;
if (((this.KeyFile != null) && (this.KeyFile.Length > 0)) || ((this.KeyContainer != null) && (this.KeyContainer.Length > 0)))
{
if (this.DelaySign)
{
none = StrongNameLevel.DelaySigned;
}
else
{
none = StrongNameLevel.FullySigned;
}
}
StrongNameLevel assemblyStrongNameLevel = StrongNameUtils.GetAssemblyStrongNameLevel(wrapperInfo.path);
if (none != assemblyStrongNameLevel)
{
return false;
}
if ((none == StrongNameLevel.DelaySigned) || (none == StrongNameLevel.FullySigned))
{
StrongNameKeyPair pair;
byte[] publicKey = null;
StrongNameUtils.GetStrongNameKey(base.Log, this.KeyFile, this.KeyContainer, out pair, out publicKey);
AssemblyName assemblyName = AssemblyName.GetAssemblyName(wrapperInfo.path);
if (assemblyName == null)
{
return false;
}
byte[] buffer2 = assemblyName.GetPublicKey();
if (buffer2.Length != publicKey.Length)
{
return false;
}
for (int i = 0; i < buffer2.Length; i++)
{
if (buffer2[i] != publicKey[i])
{
return false;
}
}
}
try
{
wrapperInfo.assembly = Assembly.UnsafeLoadFrom(wrapperInfo.path);
}
catch (BadImageFormatException)
{
wrapperInfo.assembly = null;
}
return (wrapperInfo.assembly != null);
}
/*
* Method: Resolve
*
* Gets the resolved assembly path for the typelib wrapper.
*/
internal override bool FindExistingWrapper(out ComReferenceWrapperInfo wrapperInfo, DateTime componentTimestamp)
{
wrapperInfo = null;
// Let NDP do the dirty work...
TypeLibConverter converter = new TypeLibConverter();
string asmName, asmCodeBase;
if (!converter.GetPrimaryInteropAssembly(ReferenceInfo.attr.guid, ReferenceInfo.attr.wMajorVerNum, ReferenceInfo.attr.wMinorVerNum, ReferenceInfo.attr.lcid,
out asmName, out asmCodeBase))
{
return false;
}
// let's try to load the assembly to determine its path and if it's there
try
{
if (asmCodeBase != null && asmCodeBase.Length > 0)
{
Uri uri = new Uri(asmCodeBase);
// make sure the PIA can be loaded
Assembly assembly = Assembly.UnsafeLoadFrom(uri.LocalPath);
// got here? then assembly must have been loaded successfully.
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = uri.LocalPath;
wrapperInfo.assembly = assembly;
// We need to remember the original assembly name of this PIA in case it gets redirected to a newer
// version and other COM components use that name to reference the PIA. assembly.FullName wouldn't
// work here since we'd get the redirected assembly name.
wrapperInfo.originalPiaName = new AssemblyNameExtension(AssemblyName.GetAssemblyName(uri.LocalPath));
}
else
{
Assembly assembly = Assembly.Load(asmName);
// got here? then assembly must have been loaded successfully.
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = assembly.Location;
wrapperInfo.assembly = assembly;
// We need to remember the original assembly name of this PIA in case it gets redirected to a newer
// version and other COM components use that name to reference the PIA.
wrapperInfo.originalPiaName = new AssemblyNameExtension(asmName, true);
}
}
catch (FileNotFoundException)
{
// This means that assembly file cannot be found.
// We don't need to do anything here; wrapperInfo is not set
// and we'll assume that the assembly doesn't exist.
}
catch (BadImageFormatException)
{
// Similar case as above, except we should additionally warn the user that the assembly file
// is not really a valid assembly file.
if (!Silent)
{
Log.LogWarningWithCodeFromResources("ResolveComReference.BadAssemblyImage", asmName);
}
}
// have we found the wrapper?
if (wrapperInfo != null)
{
return true;
}
return false;
}
internal bool GenerateWrapper(out ComReferenceWrapperInfo wrapperInfo)
{
wrapperInfo = null;
string typeLibName = this.ReferenceInfo.typeLibName;
string wrapperPath = base.GetWrapperPath();
StrongNameKeyPair keyPair = null;
byte[] publicKey = null;
StrongNameUtils.GetStrongNameKey(base.Log, base.KeyFile, base.KeyContainer, out keyPair, out publicKey);
if (base.DelaySign)
{
keyPair = null;
if (publicKey == null)
{
base.Log.LogErrorWithCodeFromResources(null, this.ReferenceInfo.SourceItemSpec, 0, 0, 0, 0, "StrongNameUtils.NoPublicKeySpecified", new object[0]);
throw new StrongNameException();
}
}
else
{
publicKey = null;
if (keyPair == null)
{
if ((base.KeyContainer != null) && (base.KeyContainer.Length > 0))
{
base.Log.LogErrorWithCodeFromResources(null, this.ReferenceInfo.SourceItemSpec, 0, 0, 0, 0, "ResolveComReference.StrongNameUtils.NoKeyPairInContainer", new object[] { base.KeyContainer });
throw new StrongNameException();
}
if ((base.KeyFile != null) && (base.KeyFile.Length > 0))
{
base.Log.LogErrorWithCodeFromResources(null, this.ReferenceInfo.SourceItemSpec, 0, 0, 0, 0, "ResolveComReference.StrongNameUtils.NoKeyPairInFile", new object[] { base.KeyFile });
throw new StrongNameException();
}
}
}
bool flag = true;
if (!base.ExecuteAsTool)
{
TypeLibConverter converter = new TypeLibConverter();
AssemblyBuilder assemblyBuilder = null;
try
{
TypeLibImporterFlags flags = TypeLibImporterFlags.TransformDispRetVals | TypeLibImporterFlags.SafeArrayAsSystemArray;
if (this.noClassMembers)
{
flags |= TypeLibImporterFlags.PreventClassMembers;
}
string str4 = this.targetProcessorArchitecture;
if (str4 != null)
{
if (!(str4 == "MSIL"))
{
if (str4 == "AMD64")
{
goto Label_0323;
}
if (str4 == "IA64")
{
goto Label_032F;
}
if (str4 == "x86")
{
goto Label_033B;
}
}
else
{
flags |= TypeLibImporterFlags.ImportAsAgnostic;
}
}
goto Label_0345;
Label_0323:
flags |= TypeLibImporterFlags.ImportAsX64;
goto Label_0345;
Label_032F:
flags |= TypeLibImporterFlags.ImportAsItanium;
goto Label_0345;
Label_033B:
flags |= TypeLibImporterFlags.ImportAsX86;
Label_0345:
assemblyBuilder = converter.ConvertTypeLibToAssembly(this.ReferenceInfo.typeLibPointer, wrapperPath, flags, this, publicKey, keyPair, typeLibName, null);
}
catch (COMException exception)
{
base.Log.LogWarningWithCodeFromResources("ResolveComReference.ErrorCreatingWrapperAssembly", new object[] { this.ItemName, exception.Message });
throw new ComReferenceResolutionException(exception);
}
if (!this.HasTemporaryWrapper)
{
this.WriteWrapperToDisk(assemblyBuilder, wrapperPath);
}
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = this.HasTemporaryWrapper ? null : wrapperPath;
wrapperInfo.assembly = assemblyBuilder;
return flag;
}
ResolveComReference.TlbImp imp = new ResolveComReference.TlbImp {
BuildEngine = base.BuildEngine,
EnvironmentVariables = base.EnvironmentVariables,
DelaySign = base.DelaySign,
KeyContainer = base.KeyContainer,
KeyFile = base.KeyFile,
OutputAssembly = wrapperPath,
ToolPath = base.ToolPath,
TypeLibName = this.ReferenceInfo.typeLibPath,
AssemblyNamespace = typeLibName,
AssemblyVersion = null,
PreventClassMembers = this.noClassMembers,
SafeArrayAsSystemArray = true,
Transform = ResolveComReference.TlbImpTransformFlags.TransformDispRetVals
};
if (this.referenceFiles != null)
{
string fullPathToOutput = Path.GetFullPath(wrapperPath);
imp.ReferenceFiles = (from rf in this.referenceFiles
where string.Compare(fullPathToOutput, rf, StringComparison.OrdinalIgnoreCase) != 0
select rf).ToArray<string>();
}
string targetProcessorArchitecture = this.targetProcessorArchitecture;
if (targetProcessorArchitecture != null)
{
if (!(targetProcessorArchitecture == "MSIL"))
{
if (targetProcessorArchitecture == "AMD64")
{
imp.Machine = "X64";
}
else if (targetProcessorArchitecture == "IA64")
{
imp.Machine = "Itanium";
}
else if (targetProcessorArchitecture == "x86")
{
imp.Machine = "X86";
}
else
{
imp.Machine = this.targetProcessorArchitecture;
}
}
else
{
imp.Machine = "Agnostic";
}
}
flag = imp.Execute();
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = this.HasTemporaryWrapper ? null : wrapperPath;
return flag;
}
/*
* Method: ResolveComClassicReference
*
* Resolves a COM classic reference given the type library attributes and the type of wrapper to use.
* If wrapper type is not specified, this method will first look for an existing reference in the project,
* fall back to looking for a PIA and finally try to generate a regular tlbimp wrapper.
*/
internal bool ResolveComClassicReference(ComReferenceInfo referenceInfo, string outputDirectory, string wrapperType, string refName, bool topLevelRef, List<string> dependencyPaths, out ComReferenceWrapperInfo wrapperInfo)
{
wrapperInfo = null;
bool retVal = false;
// only look for an existing PIA
if (ComReferenceTypes.IsPia(wrapperType))
{
retVal = ResolveComReferencePia(referenceInfo, refName, out wrapperInfo);
}
// find/generate a tlb wrapper
else if (ComReferenceTypes.IsTlbImp(wrapperType))
{
retVal = ResolveComReferenceTlb(referenceInfo, outputDirectory, refName, topLevelRef, dependencyPaths, out wrapperInfo);
}
// find/generate an Ax wrapper
else if (ComReferenceTypes.IsAxImp(wrapperType))
{
retVal = ResolveComReferenceAx(referenceInfo, outputDirectory, refName, out wrapperInfo);
}
// find/generate a pia/tlb wrapper (it's only possible to get here via a callback)
else if (wrapperType == null || ComReferenceTypes.IsPiaOrTlbImp(wrapperType))
{
// if this reference does not exist in the project, try looking for a PIA first
retVal = ResolveComReferencePia(referenceInfo, refName, out wrapperInfo);
if (!retVal)
{
// failing that, try a regular tlb wrapper
retVal = ResolveComReferenceTlb(referenceInfo, outputDirectory, refName, false /* dependency */, dependencyPaths, out wrapperInfo);
}
}
else
{
ErrorUtilities.VerifyThrow(false, "Unknown wrapper type!");
}
referenceInfo.resolvedWrapper = wrapperInfo;
// update the timestamp cache with the timestamp of the component we just processed
_timestampCache[referenceInfo.strippedTypeLibPath] = File.GetLastWriteTime(referenceInfo.strippedTypeLibPath);
return retVal;
}
/*
* Method: ResolveComClassicReference
*
* Resolves a COM classic reference given the type library attributes and the type of wrapper to use.
* If wrapper type is not specified, this method will first look for an existing reference in the project,
* fall back to looking for a PIA and finally try to generate a regular tlbimp wrapper.
*
* This is the method available for references to call back to resolve their dependencies
*/
bool IComReferenceResolver.ResolveComClassicReference(TYPELIBATTR typeLibAttr, string outputDirectory, string wrapperType, string refName, out ComReferenceWrapperInfo wrapperInfo)
{
// does this reference exist in the project or is it a dependency?
bool topLevelRef = false;
wrapperInfo = null;
// remap the type lib to ADO 2.7 if necessary
TYPELIBATTR oldAttr = typeLibAttr;
if (ComReference.RemapAdoTypeLib(Log, Silent, ref typeLibAttr) && !Silent)
{
// if successfully remapped the reference to ADO 2.7, notify the user
Log.LogMessageFromResources(MessageImportance.Low, "ResolveComReference.RemappingAdoTypeLib", oldAttr.wMajorVerNum, oldAttr.wMinorVerNum);
}
ComReferenceInfo referenceInfo;
// find an existing ref in the project (taking the desired wrapperType into account, if any)
if (IsExistingProjectReference(typeLibAttr, wrapperType, out referenceInfo))
{
// IsExistingProjectReference should not return null...
Debug.Assert(referenceInfo != null, "IsExistingProjectReference should not return null");
topLevelRef = true;
wrapperType = referenceInfo.taskItem.GetMetadata(ComReferenceItemMetadataNames.wrapperTool);
}
// was this dependency already processed?
else if (IsExistingDependencyReference(typeLibAttr, out referenceInfo))
{
Debug.Assert(referenceInfo != null, "IsExistingDependencyReference should not return null");
// we've seen this dependency before, so we should know what its wrapper type is.
if (wrapperType == null || ComReferenceTypes.IsPiaOrTlbImp(wrapperType))
{
string typeLibKey = ComReference.UniqueKeyFromTypeLibAttr(typeLibAttr);
if (_cachePia.ContainsKey(typeLibKey))
{
wrapperType = ComReferenceTypes.primary;
}
else if (_cacheTlb.ContainsKey(typeLibKey))
{
wrapperType = ComReferenceTypes.tlbimp;
}
}
}
// if not found anywhere, create a new ComReferenceInfo object and resolve it.
else
{
try
{
referenceInfo = new ComReferenceInfo();
if (referenceInfo.InitializeWithTypeLibAttrs(Log, Silent, typeLibAttr, null, this.TargetProcessorArchitecture))
{
allDependencyRefs.Add(referenceInfo);
}
else
{
referenceInfo.ReleaseTypeLibPtr();
return false;
}
}
catch (COMException ex)
{
if (!Silent)
{
Log.LogWarningWithCodeFromResources("ResolveComReference.CannotLoadTypeLib", typeLibAttr.guid,
typeLibAttr.wMajorVerNum.ToString(CultureInfo.InvariantCulture),
typeLibAttr.wMinorVerNum.ToString(CultureInfo.InvariantCulture),
ex.Message);
}
referenceInfo.ReleaseTypeLibPtr();
// can't resolve an unregistered and unknown dependency, so return false
return false;
}
}
// if we don't have the reference name, use the typelib name
if (refName == null)
{
refName = referenceInfo.typeLibName;
}
return ResolveComClassicReference(referenceInfo, outputDirectory, wrapperType, refName, topLevelRef, referenceInfo.dependentWrapperPaths, out wrapperInfo);
}
internal bool ResolveComReferenceAx(ComReferenceInfo referenceInfo, string outputDirectory, string refName, out ComReferenceWrapperInfo wrapperInfo)
{
wrapperInfo = null;
string key = ComReference.UniqueKeyFromTypeLibAttr(referenceInfo.attr);
if (this.cacheAx.ContainsKey(key))
{
wrapperInfo = (ComReferenceWrapperInfo) this.cacheAx[key];
return true;
}
try
{
AxReference reference = new AxReference(base.Log, this, referenceInfo, refName, outputDirectory, this.DelaySign, this.KeyFile, this.KeyContainer, this.IncludeVersionInInteropName, this.aximpPath, base.BuildEngine, this.EnvironmentVariables);
if (!reference.FindExistingWrapper(out wrapperInfo, this.timestampCache[referenceInfo.typeLibPath]) && !reference.GenerateWrapper(out wrapperInfo))
{
return false;
}
this.cacheAx.Add(key, wrapperInfo);
}
catch (Exception exception)
{
if (Microsoft.Build.Shared.ExceptionHandling.NotExpectedException(exception))
{
throw;
}
return false;
}
return true;
}
/*
* Method: IsWrapperUpToDate
*
* Checks if the existing wrapper is up to date.
*/
protected virtual bool IsWrapperUpToDate(ComReferenceWrapperInfo wrapperInfo, DateTime componentTimestamp)
{
Debug.Assert(ReferenceInfo.strippedTypeLibPath != null && ReferenceInfo.strippedTypeLibPath.Length > 0, "ReferenceInfo.path should be valid if we got here");
if (ReferenceInfo.strippedTypeLibPath == null || ReferenceInfo.strippedTypeLibPath.Length == 0)
throw new ComReferenceResolutionException();
// if wrapper doesn't exist, wrapper is obviously not up to date
if (!File.Exists(wrapperInfo.path))
return false;
// if typelib file has a DIFFERENT last write time, wrapper is not up to date
// the reason we're comparing write times in an unusual way is that type libraries are unusual
// "source files" for wrappers. If you upgrade/downgrade a system component, its write
// time may be earlier than before but we should still regenerate the wrapper.
if (DateTime.Compare(File.GetLastWriteTime(ReferenceInfo.strippedTypeLibPath), componentTimestamp) != 0)
return false;
// Compare our the existing wrapper's strong name state to the one we are requesting.
if (!SigningRequirementsMatchExistingWrapper(wrapperInfo))
{
return false;
}
// ok, everything's looking fine, now just verify the assembly file is valid
try
{
wrapperInfo.assembly = Assembly.UnsafeLoadFrom(wrapperInfo.path);
}
catch (BadImageFormatException)
{
// ouch, this assembly is malformed... need to regenerate the wrapper.
wrapperInfo.assembly = null;
}
return (wrapperInfo.assembly != null);
}
internal bool ResolveComReferenceTlb(ComReferenceInfo referenceInfo, string outputDirectory, string refName, bool topLevelRef, List<string> dependencyPaths, out ComReferenceWrapperInfo wrapperInfo)
{
wrapperInfo = null;
string key = ComReference.UniqueKeyFromTypeLibAttr(referenceInfo.attr);
if (this.cacheTlb.ContainsKey(key))
{
wrapperInfo = (ComReferenceWrapperInfo) this.cacheTlb[key];
return true;
}
bool hasTemporaryWrapper = false;
if (!topLevelRef)
{
foreach (ComReferenceInfo info in this.allProjectRefs)
{
if ((ComReferenceTypes.IsTlbImp(info.taskItem.GetMetadata("WrapperTool")) && !ComReference.AreTypeLibAttrEqual(referenceInfo.attr, info.attr)) && (string.Compare(referenceInfo.typeLibName, info.typeLibName, StringComparison.OrdinalIgnoreCase) == 0))
{
hasTemporaryWrapper = true;
}
}
}
try
{
List<string> referenceFiles = new List<string>(this.GetResolvedAssemblyReferenceItemSpecs());
if (dependencyPaths != null)
{
referenceFiles.AddRange(dependencyPaths);
}
TlbReference reference = new TlbReference(base.Log, this, referenceFiles, referenceInfo, refName, outputDirectory, hasTemporaryWrapper, this.DelaySign, this.KeyFile, this.KeyContainer, this.NoClassMembers, this.TargetProcessorArchitecture, this.IncludeVersionInInteropName, this.ExecuteAsTool, this.tlbimpPath, base.BuildEngine, this.EnvironmentVariables);
if (!reference.FindExistingWrapper(out wrapperInfo, this.timestampCache[referenceInfo.typeLibPath]) && !reference.GenerateWrapper(out wrapperInfo))
{
return false;
}
this.cacheTlb.Add(key, wrapperInfo);
}
catch (Exception exception)
{
if (Microsoft.Build.Shared.ExceptionHandling.NotExpectedException(exception))
{
throw;
}
return false;
}
return true;
}
/*
* Method: FindExistingWrapper
*
* Checks if there's a preexisting wrapper for this reference.
*/
internal override bool FindExistingWrapper(out ComReferenceWrapperInfo wrapperInfo, DateTime componentTimestamp)
{
wrapperInfo = null;
string wrapperPath = GetWrapperPath();
// now see if the wrapper assembly actually exists
if (!File.Exists(wrapperPath))
{
return false;
}
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = wrapperPath;
return IsWrapperUpToDate(wrapperInfo, componentTimestamp);
}
/*
* Method: GenerateWrapper
*
* Generates a wrapper for this reference.
*/
internal bool GenerateWrapper(out ComReferenceWrapperInfo wrapperInfo)
{
wrapperInfo = null;
string rootNamespace = ReferenceInfo.typeLibName;
string wrapperPath = GetWrapperPath();
bool generateWrapperSucceeded = true;
if (ExecuteAsTool)
{
// delegate generation of the assembly to an instance of the TlbImp ToolTask. MUST
// HAVE SET SDKTOOLSPATH TO THE TARGET SDK TO WORK
var tlbImp = new ResolveComReference.TlbImp();
tlbImp.BuildEngine = BuildEngine;
tlbImp.EnvironmentVariables = EnvironmentVariables;
tlbImp.DelaySign = DelaySign;
tlbImp.KeyContainer = KeyContainer;
tlbImp.KeyFile = KeyFile;
tlbImp.OutputAssembly = wrapperPath;
tlbImp.ToolPath = ToolPath;
tlbImp.TypeLibName = ReferenceInfo.fullTypeLibPath;
tlbImp.AssemblyNamespace = rootNamespace;
tlbImp.AssemblyVersion = null;
tlbImp.PreventClassMembers = _noClassMembers;
tlbImp.SafeArrayAsSystemArray = true;
tlbImp.Silent = Silent;
tlbImp.Transform = ResolveComReference.TlbImpTransformFlags.TransformDispRetVals;
if (_referenceFiles != null)
{
// Issue is that there may be reference dependencies that need to be passed in. It is possible
// that the set of references will also contain the file that is meant to be written here (when reference resolution
// found the file in the output folder). We need to filter out this case.
var fullPathToOutput = Path.GetFullPath(wrapperPath); // Current directory is the directory of the project file.
tlbImp.ReferenceFiles = _referenceFiles.Where(rf => String.Compare(fullPathToOutput, rf, StringComparison.OrdinalIgnoreCase) != 0).ToArray();
}
switch (_targetProcessorArchitecture)
{
case UtilitiesProcessorArchitecture.MSIL:
tlbImp.Machine = "Agnostic";
break;
case UtilitiesProcessorArchitecture.AMD64:
tlbImp.Machine = "X64";
break;
case UtilitiesProcessorArchitecture.IA64:
tlbImp.Machine = "Itanium";
break;
case UtilitiesProcessorArchitecture.X86:
tlbImp.Machine = "X86";
break;
case UtilitiesProcessorArchitecture.ARM:
tlbImp.Machine = "ARM";
break;
case null:
break;
default:
// Transmit the flag directly from the .targets files and rely on tlbimp.exe to produce a good error message.
tlbImp.Machine = _targetProcessorArchitecture;
break;
}
generateWrapperSucceeded = tlbImp.Execute();
// store the wrapper info...
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = (HasTemporaryWrapper) ? null : wrapperPath;
// Changed to ReflectionOnlyLoadFrom, related to bug:
// RCR: Bad COM-interop assemblies being generated when using 64-bit MSBuild to build a project that is targeting 32-bit platform
// The original call to UnsafeLoadFrom loads the assembly in preparation for execution. If the assembly is x86 and this is x64 msbuild.exe then we
// have problems (UnsafeLoadFrom will fail). We only use this assembly for reference resolution so we don't need to be ready to execute the code.
//
// Its actually not clear to me that we even need to load the assembly at all. Reference resoluton is only used in the !ExecuteAsTool which is not
// where we are right now.
//
// If we really do need to load it then:
//
// wrapperInfo.assembly = Assembly.ReflectionOnlyLoadFrom(wrapperPath);
}
else
{
// use framework classes in-proc to generate the assembly
TypeLibConverter converter = new TypeLibConverter();
AssemblyBuilder assemblyBuilder = null;
StrongNameKeyPair keyPair;
byte[] publicKey;
GetAndValidateStrongNameKey(out keyPair, out publicKey);
try
{
TypeLibImporterFlags flags = TypeLibImporterFlags.SafeArrayAsSystemArray | TypeLibImporterFlags.TransformDispRetVals;
if (_noClassMembers)
{
flags |= TypeLibImporterFlags.PreventClassMembers;
}
switch (_targetProcessorArchitecture)
{
case UtilitiesProcessorArchitecture.MSIL:
flags |= TypeLibImporterFlags.ImportAsAgnostic;
break;
case UtilitiesProcessorArchitecture.AMD64:
flags |= TypeLibImporterFlags.ImportAsX64;
break;
case UtilitiesProcessorArchitecture.IA64:
flags |= TypeLibImporterFlags.ImportAsItanium;
break;
case UtilitiesProcessorArchitecture.X86:
flags |= TypeLibImporterFlags.ImportAsX86;
break;
case UtilitiesProcessorArchitecture.ARM:
flags |= TypeLibImporterFlags.ImportAsArm;
break;
default:
// Let the type importer decide.
break;
}
// Start the conversion process. We'll get callbacks on ITypeLibImporterNotifySink to resolve dependent refs.
assemblyBuilder = converter.ConvertTypeLibToAssembly(ReferenceInfo.typeLibPointer, wrapperPath,
flags, this, publicKey, keyPair, rootNamespace, null);
}
catch (COMException ex)
{
if (!Silent)
{
Log.LogWarningWithCodeFromResources("ResolveComReference.ErrorCreatingWrapperAssembly", ItemName, ex.Message);
}
throw new ComReferenceResolutionException(ex);
}
// if we're done, and this is not a temporary wrapper, write it out to disk
if (!HasTemporaryWrapper)
{
WriteWrapperToDisk(assemblyBuilder, wrapperPath);
}
// store the wrapper info...
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = (HasTemporaryWrapper) ? null : wrapperPath;
wrapperInfo.assembly = assemblyBuilder;
}
// ...and we're done!
return(generateWrapperSucceeded);
}
internal bool GenerateWrapper(out ComReferenceWrapperInfo wrapperInfo)
{
wrapperInfo = null;
string typeLibName = this.ReferenceInfo.typeLibName;
string wrapperPath = base.GetWrapperPath();
StrongNameKeyPair keyPair = null;
byte[] publicKey = null;
StrongNameUtils.GetStrongNameKey(base.Log, base.KeyFile, base.KeyContainer, out keyPair, out publicKey);
if (base.DelaySign)
{
keyPair = null;
if (publicKey == null)
{
base.Log.LogErrorWithCodeFromResources(null, this.ReferenceInfo.SourceItemSpec, 0, 0, 0, 0, "StrongNameUtils.NoPublicKeySpecified", new object[0]);
throw new StrongNameException();
}
}
else
{
publicKey = null;
if (keyPair == null)
{
if ((base.KeyContainer != null) && (base.KeyContainer.Length > 0))
{
base.Log.LogErrorWithCodeFromResources(null, this.ReferenceInfo.SourceItemSpec, 0, 0, 0, 0, "ResolveComReference.StrongNameUtils.NoKeyPairInContainer", new object[] { base.KeyContainer });
throw new StrongNameException();
}
if ((base.KeyFile != null) && (base.KeyFile.Length > 0))
{
base.Log.LogErrorWithCodeFromResources(null, this.ReferenceInfo.SourceItemSpec, 0, 0, 0, 0, "ResolveComReference.StrongNameUtils.NoKeyPairInFile", new object[] { base.KeyFile });
throw new StrongNameException();
}
}
}
bool flag = true;
if (!base.ExecuteAsTool)
{
TypeLibConverter converter = new TypeLibConverter();
AssemblyBuilder assemblyBuilder = null;
try
{
TypeLibImporterFlags flags = TypeLibImporterFlags.TransformDispRetVals | TypeLibImporterFlags.SafeArrayAsSystemArray;
if (this.noClassMembers)
{
flags |= TypeLibImporterFlags.PreventClassMembers;
}
string str4 = this.targetProcessorArchitecture;
if (str4 != null)
{
if (!(str4 == "MSIL"))
{
if (str4 == "AMD64")
{
goto Label_0323;
}
if (str4 == "IA64")
{
goto Label_032F;
}
if (str4 == "x86")
{
goto Label_033B;
}
}
else
{
flags |= TypeLibImporterFlags.ImportAsAgnostic;
}
}
goto Label_0345;
Label_0323:
flags |= TypeLibImporterFlags.ImportAsX64;
goto Label_0345;
Label_032F:
flags |= TypeLibImporterFlags.ImportAsItanium;
goto Label_0345;
Label_033B:
flags |= TypeLibImporterFlags.ImportAsX86;
Label_0345:
assemblyBuilder = converter.ConvertTypeLibToAssembly(this.ReferenceInfo.typeLibPointer, wrapperPath, flags, this, publicKey, keyPair, typeLibName, null);
}
catch (COMException exception)
{
base.Log.LogWarningWithCodeFromResources("ResolveComReference.ErrorCreatingWrapperAssembly", new object[] { this.ItemName, exception.Message });
throw new ComReferenceResolutionException(exception);
}
if (!this.HasTemporaryWrapper)
{
this.WriteWrapperToDisk(assemblyBuilder, wrapperPath);
}
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = this.HasTemporaryWrapper ? null : wrapperPath;
wrapperInfo.assembly = assemblyBuilder;
return(flag);
}
ResolveComReference.TlbImp imp = new ResolveComReference.TlbImp {
BuildEngine = base.BuildEngine,
EnvironmentVariables = base.EnvironmentVariables,
DelaySign = base.DelaySign,
KeyContainer = base.KeyContainer,
KeyFile = base.KeyFile,
OutputAssembly = wrapperPath,
ToolPath = base.ToolPath,
TypeLibName = this.ReferenceInfo.typeLibPath,
AssemblyNamespace = typeLibName,
AssemblyVersion = null,
PreventClassMembers = this.noClassMembers,
SafeArrayAsSystemArray = true,
Transform = ResolveComReference.TlbImpTransformFlags.TransformDispRetVals
};
if (this.referenceFiles != null)
{
string fullPathToOutput = Path.GetFullPath(wrapperPath);
imp.ReferenceFiles = (from rf in this.referenceFiles
where string.Compare(fullPathToOutput, rf, StringComparison.OrdinalIgnoreCase) != 0
select rf).ToArray <string>();
}
string targetProcessorArchitecture = this.targetProcessorArchitecture;
if (targetProcessorArchitecture != null)
{
if (!(targetProcessorArchitecture == "MSIL"))
{
if (targetProcessorArchitecture == "AMD64")
{
imp.Machine = "X64";
}
else if (targetProcessorArchitecture == "IA64")
{
imp.Machine = "Itanium";
}
else if (targetProcessorArchitecture == "x86")
{
imp.Machine = "X86";
}
else
{
imp.Machine = this.targetProcessorArchitecture;
}
}
else
{
imp.Machine = "Agnostic";
}
}
flag = imp.Execute();
wrapperInfo = new ComReferenceWrapperInfo();
wrapperInfo.path = this.HasTemporaryWrapper ? null : wrapperPath;
return(flag);
}
internal abstract bool FindExistingWrapper(out ComReferenceWrapperInfo wrapperInfo, DateTime componentTimestamp);
/// <summary>
/// Helper function - resolves a PIA COM classic reference given the type library attributes.
/// </summary>
/// <param name="referenceInfo">Information about the reference to be resolved</param>
/// <param name="refName">Name of reference</param>
/// <param name="wrapperInfo">Information about wrapper locations</param>
/// <returns>True if the reference was already found or successfully generated, false otherwise.</returns>
internal bool ResolveComReferencePia(ComReferenceInfo referenceInfo, string refName, out ComReferenceWrapperInfo wrapperInfo)
{
wrapperInfo = null;
string typeLibKey = ComReference.UniqueKeyFromTypeLibAttr(referenceInfo.attr);
// look in the PIA cache first
if (_cachePia.ContainsKey(typeLibKey))
{
wrapperInfo = (ComReferenceWrapperInfo)_cachePia[typeLibKey];
return true;
}
try
{
// if not in the cache, we have no choice but to go looking for the PIA
PiaReference reference = new PiaReference(Log, Silent, referenceInfo, refName);
// if not found, fail (we do not fall back to tlbimp wrappers if we're looking specifically for a PIA)
if (!reference.FindExistingWrapper(out wrapperInfo, _timestampCache[referenceInfo.strippedTypeLibPath]))
{
return false;
}
// if found, add it to the PIA cache
_cachePia.Add(typeLibKey, wrapperInfo);
}
catch (Exception e) when (ExceptionHandling.IsIoRelatedException(e))
{
return false;
}
return true;
}
