/// <summary>
/// Returns the original location of the corresponding assembly if available, otherwise returns the location of the shadow copy.
/// If the corresponding assembly is not in the GAC, null is returned.
/// </summary>
public static string GetLocation(AssemblyReference assemblyReference){
if (assemblyReference == null) { Debug.Fail("assemblyReference == null"); return null; }
lock(GlobalAssemblyCache.Lock){
if (!GlobalAssemblyCache.FusionLoaded){
GlobalAssemblyCache.FusionLoaded = true;
System.Reflection.Assembly systemAssembly = typeof(object).Assembly;
//^ assume systemAssembly != null && systemAssembly.Location != null;
string dir = Path.GetDirectoryName(systemAssembly.Location);
//^ assume dir != null;
GlobalAssemblyCache.LoadLibrary(Path.Combine(dir, "fusion.dll"));
}
IAssemblyEnum assemblyEnum;
CreateAssemblyEnum(out assemblyEnum, null, null, ASM_CACHE.GAC, 0);
if (assemblyEnum == null) return null;
IApplicationContext applicationContext;
IAssemblyName currentName;
while (assemblyEnum.GetNextAssembly(out applicationContext, out currentName, 0) == 0){
//^ assume currentName != null;
AssemblyName aName = new AssemblyName(currentName);
if (assemblyReference.Matches(aName.Name, aName.Version, aName.Culture, aName.PublicKeyToken)){
string codeBase = aName.CodeBase;
if (codeBase != null && codeBase.StartsWith("file:///"))
return codeBase.Substring(8);
return aName.GetLocation();
}
}
return null;
}
}
public AssemblyReference ImportAssembly(IAssemblyDescriptor assemblyInfo)
{
var table = _tableStreamBuffer.GetTable<AssemblyReference>();
var reference = table.FirstOrDefault(x => _signatureComparer.MatchAssemblies(x, assemblyInfo));
if (reference == null)
table.Add(reference = new AssemblyReference(assemblyInfo));
return reference;
}
internal static CilAssemblyReference Create(AssemblyReference assemblyRef, int token, ref CilReaders readers, CilAssembly assemblyDefinition)
{
CilAssemblyReference assembly = new CilAssemblyReference();
assembly._assemblyRef = assemblyRef;
assembly._token = token;
assembly._readers = readers;
assembly._assemblyDefinition = assemblyDefinition;
return assembly;
}
private Tuple<SemanticVersion, string> ResolveAssembly(DllReference parentAssembly, AssemblyReference assemblyDependency)
{
var assemblies = _assemblyCacheService.Assemblies;
var conflictingAssemblies = _assemblyCacheService.ConflictingAssemblies;
//RULE 1. It's an assembly that is known on nuget.org or other. Official or Snapshot doesn't matter
if(_resolutionLevel!=ResolutionLevelEnum.DontResolveDependancyUsingOfficialRepository)
{
var nugetPackage = _mappingService.GetNuGetPackage(_assemblyCacheService, assemblyDependency);
if (nugetPackage != null)
{
Trace.TraceInformation($"{assemblyDependency.Item2}-{assemblyDependency.Item1} found in official repository as {nugetPackage.Item2}-{nugetPackage.Item1}");
return nugetPackage;
}
}
//RULE 2. The reference is not known but it match with at least one dll present on local folder
var resolvedAssembly = new Tuple<SemanticVersion, string>(new SemanticVersion(assemblyDependency.Item1), assemblyDependency.Item2);
if (_assemblyCacheService.Assemblies.ContainsKey(resolvedAssembly)
&& conflictingAssemblies[assemblyDependency].Count(_ => string.IsNullOrEmpty(_.SpecialVersion)) == 1)
{
Trace.TraceInformation($"{assemblyDependency.Item2}-{assemblyDependency.Item1} found at {assemblies[resolvedAssembly].Path}");
return assemblies[resolvedAssembly].Id;
}
if (conflictingAssemblies.ContainsKey(assemblyDependency)
&& conflictingAssemblies[assemblyDependency].Count(_ => string.IsNullOrEmpty(_.SpecialVersion)) > 1
&& _resolutionLevel != ResolutionLevelEnum.DontResolveDependancyIgnoringMultipleAssembliesWithSameVersion)
// there might be more than one dll with the expected version...Try to find the best one...
resolvedAssembly = RetrieveConflictingDependancyFromCacheOrResolve(assemblies, parentAssembly, conflictingAssemblies[assemblyDependency], assemblyDependency);
// RULE 3. Let's try to find if there is a snapshot or a equivalent Version (build number mistmatch only)
if (_resolutionLevel != ResolutionLevelEnum.DontResolveDependancyIgnoringBuildNumber)
{
var resolvedpackage = CompatibleBuild(assemblyDependency, assemblies, resolvedAssembly);
if (resolvedpackage != null)
return resolvedpackage;
}
// RULE 4. Let's try to find if there is Higher Version (Patch & Build only) and take it only if there is only one possibility
if (_resolutionLevel != ResolutionLevelEnum.DontResolveDependancyIgnoringPatchAndBuildNumber)
{
var resolvedpackage = ComptiblePathAndBuild(assemblyDependency, assemblies, resolvedAssembly);
if (resolvedpackage != null)
return resolvedpackage;
}
Trace.TraceError($"Unable to find dependency {assemblyDependency.Item2}, {assemblyDependency.Item1}");
if(_useCache)
_dependencies.AddUnresolvedDependencies(assemblyDependency);
return null;
}
public void specific_version_should_serialize_using_boolean_string_that_matches_visual_studio_behaviour()
{
var reference = new AssemblyReference("log4net");
var element = new XmlDocument().CreateElement("Reference");
reference.Configure(new MSBuildItemGroup(new MSBuildProject(), element));
reference.SpecificVersion = false;
reference.Save();
element.GetElementsByTagName("SpecificVersion")[0].InnerText.ShouldEqual("False"); // and not "false"
}
public void AddUnresolvedDependencies(AssemblyReference parentAssembly)
{
var parser = new FileIniDataParser();
var versionsFileData = new IniData();
if (!Directory.Exists(@"cache\unresolved"))
Directory.CreateDirectory(@"cache\unresolved");
var file = @"cache\unresolved\" + parentAssembly.Item2 + _sectionSeparator + parentAssembly.Item1 + ".ini";
if (File.Exists(file))
return;
parser.WriteFile(file, versionsFileData);
}
public Tuple<SemanticVersion, string> GetDependencyFromCacheOrResolve(DllReference parentAssembly, AssemblyReference assemblyDependency)
{
//RULE 0. it's already in cache
Tuple<SemanticVersion, string> cachedDependancy = null;
if(_useCache)
cachedDependancy = _dependencies.Load(parentAssembly, assemblyDependency.Item2);
if (cachedDependancy != null)
return cachedDependancy;
var assembly = ResolveAssembly(parentAssembly, assemblyDependency);
if (assembly!=null && _useCache)
_dependencies.Save(assembly.Item1, assembly.Item2, parentAssembly);
return assembly;
}
public async Task <AssemblyReference[]> ResolveAssemblyReferences(ProjectConfigurationInfo[] configurations, Dictionary <string, string> globalProperties, MSBuildProject project, CancellationToken cancellationToken)
{
AssemblyReference[] refs = null;
var id = configurations [0].Configuration + "|" + configurations [0].Platform;
using (await referenceCacheLock.EnterAsync().ConfigureAwait(false)) {
// Check the cache before starting the task
if (referenceCache.TryGetValue(id, out refs))
{
return(refs);
}
// Get an id for the task, it will be used later on to cancel the task if necessary
var taskId = Interlocked.Increment(ref lastTaskId);
IDisposable cr = RegisterCancellation(cancellationToken, taskId);
MSBuildResult result;
try {
BeginOperation();
result = await builder.Run(
configurations, -1, MSBuildEvent.None, MSBuildVerbosity.Quiet,
new [] { "ResolveAssemblyReferences" }, new [] { "ReferencePath" }, null, globalProperties, taskId
).ConfigureAwait(false);
} catch (Exception ex) {
await CheckDisconnected().ConfigureAwait(false);
LoggingService.LogError("ResolveAssemblyReferences failed", ex);
return(new AssemblyReference [0]);
} finally {
cr.Dispose();
EndOperation();
}
MSBuildEvaluatedItem[] items;
if (result.Items.TryGetValue("ReferencePath", out items) && items != null)
{
refs = items.Select(it => CreateAssemblyReference(it, project)).ToArray();
}
else
{
refs = new AssemblyReference [0];
}
referenceCache [id] = refs;
}
return(refs);
}
public virtual Win32Assembly Resolve(AssemblyReference reference)
{
Win32Assembly resolvedAssembly = null;
string name = reference.Name;
if (reference.HasImage && !string.IsNullOrEmpty(reference.NETHeader.ParentAssembly.Path))
{
// Check directory of container assembly.
TryGetAssembly(Path.GetDirectoryName(reference.NETHeader.ParentAssembly.Path), name, out resolvedAssembly);
}
if (resolvedAssembly == null)
{
// Check gac directories.
if (!TryGetAssemblyGac(Path.Combine(_gacDirectory, "GAC_64"), name, out resolvedAssembly))
{
if (!TryGetAssemblyGac(Path.Combine(_gacDirectory, "GAC_32"), name, out resolvedAssembly))
{
TryGetAssemblyGac(Path.Combine(_gacDirectory, "GAC_MSIL"), name, out resolvedAssembly);
}
}
}
if (resolvedAssembly == null)
{
// Check search directories
foreach (var directory in SearchDirectories)
{
if (TryGetAssembly(directory, name, out resolvedAssembly))
{
break;
}
}
}
if (resolvedAssembly == null)
{
OnResolutionFailed(reference);
}
if (resolvedAssembly != null)
{
_assemblyCache.Add(reference.Name, resolvedAssembly);
}
return(resolvedAssembly);
}
/// <summary>
/// Returns the original location of the corresponding assembly if available, otherwise returns the location of the shadow copy.
/// If the corresponding assembly is not in the GAC, null is returned.
/// </summary>
public static string GetLocation(AssemblyReference assemblyReference)
{
#if CodeContracts
if (!probeGAC)
{
return(null);
}
#endif
if (assemblyReference == null)
{
Debug.Fail("assemblyReference == null"); return(null);
}
lock (GlobalAssemblyCache.Lock){
if (!GlobalAssemblyCache.FusionLoaded)
{
GlobalAssemblyCache.FusionLoaded = true;
System.Reflection.Assembly systemAssembly = typeof(object).Assembly;
//^ assume systemAssembly != null && systemAssembly.Location != null;
string dir = Path.GetDirectoryName(systemAssembly.Location);
//^ assume dir != null;
GlobalAssemblyCache.LoadLibrary(Path.Combine(dir, "fusion.dll"));
}
IAssemblyEnum assemblyEnum;
CreateAssemblyEnum(out assemblyEnum, null, null, ASM_CACHE.GAC, 0);
if (assemblyEnum == null)
{
return(null);
}
IApplicationContext applicationContext;
IAssemblyName currentName;
while (assemblyEnum.GetNextAssembly(out applicationContext, out currentName, 0) == 0)
{
//^ assume currentName != null;
AssemblyName aName = new AssemblyName(currentName);
if (assemblyReference.Matches(aName.Name, aName.Version, aName.Culture, aName.PublicKeyToken))
{
string codeBase = aName.CodeBase;
if (codeBase != null && codeBase.StartsWith("file:///"))
{
return(codeBase.Substring(8));
}
return(aName.GetLocation());
}
}
return(null);
}
}
/// <summary>
/// Returns a RoAssemblyName corresponding to the assembly reference.
/// </summary>
public static RoAssemblyName ToRoAssemblyName(this AssemblyReferenceHandle h, MetadataReader reader)
{
AssemblyReference a = h.GetAssemblyReference(reader);
string name = a.Name.GetString(reader);
Version version = a.Version.AdjustForUnspecifiedVersionComponents();
string culture = a.Culture.GetStringOrNull(reader);
byte[] pkOrPkt = a.PublicKeyOrToken.GetBlobBytes(reader);
AssemblyFlags flags = a.Flags;
if ((flags & AssemblyFlags.PublicKey) != 0)
{
pkOrPkt = pkOrPkt.ComputePublicKeyToken();
}
return(new RoAssemblyName(name, version, culture, pkOrPkt));
}
private static bool IsNonDefaultIncludedAssemblyReference(AssemblyReference assemblyReference)
{
var name = assemblyReference.Include;
return(!new[]
{
"System",
"System.Core",
"System.Data",
"System.Drawing",
"System.IO.Compression.FileSystem",
"System.Numerics",
"System.Runtime.Serialization",
"System.Xml",
"System.Xml.Linq"
}.Contains(name));
}
internal void RemoveAssemblyFromSet(string assembly)
{
AssemblyReference toRemove = null;
foreach (AssemblyReference reference in this.TextExpressionReferences)
{
if (reference.AssemblyName.Name == assembly)
{
toRemove = reference;
break;
}
}
if (toRemove != null)
{
this.TextExpressionReferences.Remove(toRemove);
}
}
public void can_write_and_read_display_name()
{
var project = CsProjFile.CreateAtLocation("Foo.csproj", "Foo");
var assemblyReference = new AssemblyReference("Foo")
{
DisplayName = "some name"
};
project.Add<AssemblyReference>(assemblyReference);
project.Save();
var project2 = CsProjFile.LoadFrom("Foo.csproj");
project2.Find<AssemblyReference>("Foo")
.DisplayName.ShouldEqual("some name");
}
public void can_write_and_read_Aliases()
{
var project = CsProjFile.CreateAtLocation("Foo.csproj", "Foo");
var assemblyReference = new AssemblyReference("Foo")
{
Aliases = "some alias"
};
project.Add<AssemblyReference>(assemblyReference);
project.Save();
var project2 = CsProjFile.LoadFrom("Foo.csproj");
project2.Find<AssemblyReference>("Foo")
.Aliases.ShouldEqual("some alias");
}
private AssemblyReference ToReference(string assemblyName, Assembly ownerAssembly)
{
var assemblyRef = ownerAssembly.AssemblyReferences.Find(assemblyName, true);
if (assemblyRef != null)
{
return(assemblyRef);
}
var mscorlibRef = AssemblyReference.GetMscorlib(ownerAssembly);
return(new AssemblyReference(
assemblyName,
CodeModelUtils.NeutralCulture,
mscorlibRef.Version,
MicrosoftNetFramework.BclPublicKeyToken));
}
protected internal AssemblyReference AddAssemblyNameFromItem(ITaskItem item, AssemblyReferenceType referenceType)
{
AssemblyReference assembly = new AssemblyReference {
AssemblyIdentity = AssemblyIdentity.FromAssemblyName(item.ItemSpec),
ReferenceType = referenceType
};
this.manifest.AssemblyReferences.Add(assembly);
string metadata = item.GetMetadata("HintPath");
if (!string.IsNullOrEmpty(metadata))
{
assembly.SourcePath = metadata;
}
this.SetItemAttributes(item, assembly);
return(assembly);
}
private AssemblyRefRow CreateAssemblyRefRow(AssemblyReference entity, MetadataBuilder metadata)
{
return(new AssemblyRefRow(
(ushort)entity.Version.Major,
(ushort)entity.Version.Minor,
(ushort)entity.Version.Build,
(ushort)entity.Version.Revision,
entity.Attributes,
metadata.WriteBlob(
entity.PublicKeyToken.IsNullOrEmpty()
? entity.PublicKey
: entity.PublicKeyToken),
metadata.WriteString(entity.Name),
metadata.WriteString(entity.Culture),
metadata.WriteBlob(entity.Hash)
));
}
private void LoadProjectReferences(ProjectElement result, MsBuildProjectLoader msBuildLoader, Hashtable projects)
{
IEnumerable <BuildItem> projectReferenceItems = msBuildLoader.GetProjectItems(STR_ProjectReference);
foreach (BuildItem item in projectReferenceItems)
{
string prj = item.GetMetadata(STR_Project);
ProjectInfo projectInfo = projects[prj] as ProjectInfo;
if (projectInfo == null)
{
continue;
}
AssemblyReference projectRef = new AssemblyReference(String.Empty);
projectRef.SetSourceProjectFullName(projectInfo.FilePath);
result.AddReference(projectRef);
}
}
public void ResolveCorLibUsingFileService()
{
using var service = new ByteArrayFileService();
var assemblyName = typeof(object).Assembly.GetName();
var assemblyRef = new AssemblyReference(
assemblyName.Name,
assemblyName.Version,
false,
assemblyName.GetPublicKeyToken());
var resolver = new DotNetCoreAssemblyResolver(service, new Version(3, 1, 0));
Assert.Empty(service.GetOpenedFiles());
Assert.NotNull(resolver.Resolve(assemblyRef));
Assert.NotEmpty(service.GetOpenedFiles());
}
public void ImportNewAssembly()
{
var assembly = Utilities.CreateTempNetAssembly();
var tableStream = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>();
var refTable = tableStream.GetTable <AssemblyReference>();
var importer = new ReferenceImporter(tableStream);
const string assemblyName = "some_lib";
var version = new Version(1, 2, 3, 4);
var reference = new AssemblyReference(assemblyName, version);
var newReference = importer.ImportAssembly(new AssemblyReference(assemblyName, version));
Assert.AreNotSame(reference, newReference, "Imported reference is same object as original.");
Assert.IsTrue(refTable.Contains(newReference), "Imported reference not added to reference table.");
Assert.IsTrue(_comparer.MatchAssemblies(reference, newReference), "Imported reference does not match original.");
}
public void TypeWithAssemblyNameWithPublicKey()
{
const string ns = "MyNamespace";
const string name = "MyType";
var assemblyRef = new AssemblyReference(
"MyAssembly",
new Version(1, 2, 3, 4),
false,
new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 });
var expected = new TypeReference(assemblyRef, ns, name).ToTypeSignature();
var actual = TypeNameParser.Parse(_module,
$"{ns}.{name}, {assemblyRef.FullName}");
Assert.Equal(expected, actual, _comparer);
}
public void can_write_and_read_Aliases()
{
var project = CsProjFile.CreateAtLocation("Foo.csproj", "Foo");
var assemblyReference = new AssemblyReference("Foo")
{
Aliases = "some alias"
};
project.Add <AssemblyReference>(assemblyReference);
project.Save();
var project2 = CsProjFile.LoadFrom("Foo.csproj");
project2.Find <AssemblyReference>("Foo")
.Aliases.ShouldEqual("some alias");
}
public void ImportExistingAssembly()
{
var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, true);
var image = assembly.NetDirectory.MetadataHeader.LockMetadata();
var importer = new ReferenceImporter(image);
const string assemblyName = "some_lib";
var version = new Version(1, 2, 3, 4);
var reference = new AssemblyReference(assemblyName, version);
image.Assembly.AssemblyReferences.Add(reference);
var newReference = importer.ImportAssembly(new AssemblyReference(assemblyName, version));
Assert.Equal(reference, newReference, _comparer);
}
public void can_write_and_read_fusion_name()
{
var project = CsProjFile.CreateAtLocation("Foo.csproj", "Foo");
var assemblyReference = new AssemblyReference("Foo")
{
FusionName = "some fusion"
};
project.Add <AssemblyReference>(assemblyReference);
project.Save();
var project2 = CsProjFile.LoadFrom("Foo.csproj");
project2.Find <AssemblyReference>("Foo")
.FusionName.ShouldEqual("some fusion");
}
public void can_write_and_read_Private_null()
{
var project = CsProjFile.CreateAtLocation("Foo.csproj", "Foo");
var assemblyReference = new AssemblyReference("Foo")
{
Private = null
};
project.Add <AssemblyReference>(assemblyReference);
project.Save();
var project2 = CsProjFile.LoadFrom("Foo.csproj");
project2.Find <AssemblyReference>("Foo")
.Private.ShouldBeNull();
}
public void can_write_and_read_SpecificVersion_false()
{
var project = CsProjFile.CreateAtLocation("Foo.csproj", "Foo");
var assemblyReference = new AssemblyReference("Foo")
{
SpecificVersion = false
};
project.Add <AssemblyReference>(assemblyReference);
project.Save();
var project2 = CsProjFile.LoadFrom("Foo.csproj");
project2.Find <AssemblyReference>("Foo")
.SpecificVersion.Value.ShouldBeFalse();
}
/// <summary>
/// Saves manifest values into the respective manifest
/// </summary>
/// <param name="name">Application deployment name</param>
/// <param name="version">Version number</param>
/// <param name="deploymentProvider">Deployment provider URL</param>
/// <param name="deployManifest">Deployment manifest reference</param>
/// <param name="appManifest">Application manifest reference</param>
/// <param name="appFiles">List of files to populate app manifest</param>
/// <param name="preReqs">List of prerequisites to add</param>
public static void SaveManifestValues(string name, string version, string deploymentProvider, DeployManifest deployManifest, ApplicationManifest appManifest, IList <ApplicationFile> appFiles, IList <AssemblyReference> preReqs)
{
// Populate discrete values
deployManifest.AssemblyIdentity.Name = name;
deployManifest.AssemblyIdentity.Version = version;
deployManifest.DeploymentUrl = deploymentProvider;
appManifest.AssemblyIdentity.Version = version;
// Refresh app manifest file lists
appManifest.AssemblyReferences.Clear();
appManifest.FileReferences.Clear();
// Populate prerequisites
foreach (AssemblyReference assemRef in preReqs)
{
appManifest.AssemblyReferences.Add(assemRef);
}
// Populate assembly and file references
foreach (ApplicationFile appFile in appFiles)
{
string appFilePath = Path.Combine(appFile.RelativePath, appFile.FileName);
string appManifestFolder = Path.GetDirectoryName(appManifest.SourcePath);
string appFileFullPath = Path.Combine(appManifestFolder, appFilePath) + ".deploy";
AssemblyIdentity assemId = AssemblyIdentity.FromFile(appFileFullPath);
if (assemId != null) // valid assembly
{
AssemblyReference assemRef = appManifest.AssemblyReferences.Add(appFileFullPath);
assemRef.TargetPath = appFilePath;
if (appFile.EntryPoint)
{
appManifest.EntryPoint = assemRef;
}
}
else
{
FileReference fref = appManifest.FileReferences.Add(appFileFullPath);
fref.TargetPath = appFilePath;
if (appFile.DataFile)
{
fref.IsDataFile = true;
}
}
}
}
public ManifestMetadataTableNode(NodeFactory nodeFactory)
: base(nodeFactory.Target)
{
_assemblyRefToModuleIdMap = new Dictionary <string, int>();
_moduleIdToAssemblyNameMap = new Dictionary <int, AssemblyName>();
_manifestAssemblyMvids = new List <Guid>();
_signatureEmitters = new List <ISignatureEmitter>();
_nodeFactory = nodeFactory;
_nextModuleId = 1;
if (!_nodeFactory.CompilationModuleGroup.IsCompositeBuildMode)
{
MetadataReader mdReader = _nodeFactory.CompilationModuleGroup.CompilationModuleSet.Single().MetadataReader;
_assemblyRefCount = mdReader.GetTableRowCount(TableIndex.AssemblyRef) + 1;
if (!_nodeFactory.CompilationModuleGroup.IsInputBubble)
{
for (int assemblyRefIndex = 1; assemblyRefIndex < _assemblyRefCount; assemblyRefIndex++)
{
AssemblyReferenceHandle assemblyRefHandle = MetadataTokens.AssemblyReferenceHandle(assemblyRefIndex);
AssemblyReference assemblyRef = mdReader.GetAssemblyReference(assemblyRefHandle);
string assemblyName = mdReader.GetString(assemblyRef.Name);
_assemblyRefToModuleIdMap[assemblyName] = assemblyRefIndex;
}
}
// AssemblyRefCount + 1 corresponds to ROWID 0 in the manifest metadata
_nextModuleId += _assemblyRefCount;
}
if (_nodeFactory.CompilationModuleGroup.IsCompositeBuildMode)
{
// Fill in entries for all input modules right away to make sure they have parallel indices
int nextExpectedId = 1;
foreach (EcmaModule inputModule in _nodeFactory.CompilationModuleGroup.CompilationModuleSet)
{
int acquiredId = ModuleToIndexInternal(inputModule);
if (acquiredId != nextExpectedId)
{
throw new InternalCompilerErrorException($"Manifest metadata consistency error - acquired ID {acquiredId}, expected {nextExpectedId}");
}
nextExpectedId++;
}
}
}
protected virtual void LoadReferences(ProjectElement project, Hashtable projects, XmlDocument doc, string projectDir, string projectLangTag)
{
string lReferencesQuery = String.Format(STR_ReferencesQueryFormat, projectLangTag);
XmlNodeList lReferences = doc.SelectNodes(lReferencesQuery);
int lCount = lReferences.Count;
for (int i = 0; i < lCount; i++)
{
System.Xml.XmlNode lReferenceNode = lReferences[i];
System.Xml.XmlNode lName = lReferenceNode.Attributes.GetNamedItem(STR_Name);
System.Xml.XmlNode lAssemblyName = lReferenceNode.Attributes.GetNamedItem(STR_AssemblyName);
if (lAssemblyName != null)
{
string lAssemblyNameStr = lAssemblyName.Value;
string lPath = FrameworkHelper.GetAssemblyPath(lAssemblyNameStr);
if (lPath == null || lPath.Length == 0)
{
System.Xml.XmlNode lHintPath = lReferenceNode.Attributes.GetNamedItem("HintPath");
lPath = lHintPath.Value;
lPath = PathUtilities.GetPath(projectDir, lPath);
if (File.Exists(lPath))
{
AssemblyReference lRef = new AssemblyReference(lPath);
project.AddReference(lRef);
}
}
else
{
project.AddReferenceByName(lAssemblyNameStr);
}
}
else
{
System.Xml.XmlNode lProjectRef = lReferenceNode.Attributes.GetNamedItem(STR_Project);
string lGuid = lProjectRef.Value;
ProjectInfo lInfo = projects[lGuid] as ProjectInfo;
if (lInfo != null)
{
AssemblyReference lRef = new AssemblyReference(String.Empty);
lRef.SetSourceProjectFullName(lInfo.FilePath);
project.AddReference(lRef);
}
}
}
}
private MetadataReference GetReference()
{
if (File.Exists(assemblyPath) == false)
{
if (assemblyImage != null && assemblyImage.Length > 0)
{
// Create refererence from image
return(AssemblyReference.FromImage(assemblyImage).Reference);
}
}
else
{
// Create reference from path
return(AssemblyReference.FromNameOrFile(assemblyPath).Reference);
}
throw new Exception("Assembly reference asset is invalid!");
}
public static void Build(CustomAttribute customAttribute)
{
customAttribute.Constructor =
new MethodReference(
".ctor",
new TypeReference(
"SerializableAttribute",
"System",
AssemblyReference.GetMscorlib(customAttribute.Assembly)),
new CallSite(
true,
false,
MethodCallingConvention.Default,
TypeReference.GetPrimitiveType(PrimitiveTypeCode.Void, customAttribute.Assembly),
ReadOnlyList <TypeSignature> .Empty,
0,
0));
}
/// <summary>
/// This is called if assembly reference resolution fails after probing
/// </summary>
/// <param name="reference">The assembly reference</param>
/// <param name="module">The module</param>
/// <returns>Always returns null</returns>
private AssemblyNode UnresolvedReference(AssemblyReference reference, Module module)
{
// Don't raise the event if ignored. Also, a bit of a hack for now. If it's a "System." or a
// "Microsoft." assembly, just ignore it. There are some issues resolving some of the .NETCore
// and .NETStandard assemblies due to variations in how they are distributed.
if (!ignoreIfUnresolved.Contains(reference.Name) && !reference.Name.StartsWith("System.",
StringComparison.Ordinal) && !reference.Name.StartsWith("Microsoft.", StringComparison.Ordinal))
{
OnUnresolvedAssemblyReference(reference, module);
}
else
{
this.MessageLogger(LogLevel.Warn,
$"Ignoring unresolved assembly reference: {reference.Name} ({reference.StrongName}) required by {module.Name}");
}
return(null);
}
public override void Build(CustomAttribute customAttribute)
{
customAttribute.Constructor =
new MethodReference(
".ctor",
new TypeReference(
"ObfuscateAssemblyAttribute",
"System.Reflection",
AssemblyReference.GetMscorlib(customAttribute.Assembly)),
new CallSite(
true,
false,
MethodCallingConvention.Default,
TypeReference.GetPrimitiveType(PrimitiveTypeCode.Void, customAttribute.Assembly),
new TypeSignature[]
{
TypeReference.GetPrimitiveType(PrimitiveTypeCode.Boolean, customAttribute.Assembly),
},
0,
0));
// Ctor arguments
var ctorArguments = customAttribute.CtorArguments;
ctorArguments.Clear();
ctorArguments.Add(
new CustomAttributeTypedArgument(
_assemblyIsPrivate,
TypeReference.GetPrimitiveType(PrimitiveTypeCode.Boolean, customAttribute.Assembly)));
// Named arguments
var namedArguments = customAttribute.NamedArguments;
namedArguments.Clear();
// StripAfterObfuscation
namedArguments.Add(
new CustomAttributeNamedArgument(
"StripAfterObfuscation",
CustomAttributeNamedArgumentType.Property,
new CustomAttributeTypedArgument(
_stripAfterObfuscation,
TypeReference.GetPrimitiveType(PrimitiveTypeCode.Boolean, customAttribute.Assembly))));
}
/// <summary>
/// Given a path to an assembly, identifies files in the same directory
/// that could satisfy the assembly's dependencies. May throw.
/// </summary>
/// <remarks>
/// Dependencies are identified by simply checking the name of an assembly
/// reference against a file name; if they match the file is considered a
/// dependency. Other factors, such as version, culture, public key, etc.,
/// are not considered, and so the returned collection may include items that
/// cannot in fact satisfy the original assembly's dependencies.
/// </remarks>
/// <exception cref="IOException">If the file at <paramref name="filePath"/> does not exist or cannot be accessed.</exception>
/// <exception cref="BadImageFormatException">If the file is not an assembly or is somehow corrupted.</exception>
public static ImmutableArray <string> FindAssemblySet(string filePath)
{
Debug.Assert(filePath != null);
Debug.Assert(PathUtilities.IsAbsolute(filePath));
Queue <string> workList = new Queue <string>();
HashSet <string> assemblySet = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
workList.Enqueue(filePath);
while (workList.Count > 0)
{
string assemblyPath = workList.Dequeue();
if (!assemblySet.Add(assemblyPath))
{
continue;
}
string directory = Path.GetDirectoryName(assemblyPath);
using (PEReader reader = new PEReader(FileUtilities.OpenRead(assemblyPath)))
{
MetadataReader metadataReader = reader.GetMetadataReader();
AssemblyReferenceHandleCollection assemblyReferenceHandles = metadataReader.AssemblyReferences;
foreach (AssemblyReferenceHandle handle in assemblyReferenceHandles)
{
AssemblyReference reference = metadataReader.GetAssemblyReference(handle);
string referenceName = metadataReader.GetString(reference.Name);
string referencePath = Path.Combine(directory, referenceName + ".dll");
if (!assemblySet.Contains(referencePath) &&
File.Exists(referencePath))
{
workList.Enqueue(referencePath);
}
}
}
}
return(ImmutableArray.CreateRange(assemblySet));
}
private void VisitReference(AssemblyReference reference, Dictionary <string, AssemblyReference> referenceMap, List <AssemblyReference> referenceList)
{
if (reference.Visited)
{
return;
}
reference.Visit();
foreach (string dependencyName in reference.Dependencies)
{
AssemblyReference dependencyReference;
if (referenceMap.TryGetValue(dependencyName, out dependencyReference))
{
VisitReference(dependencyReference, referenceMap, referenceList);
}
}
referenceList.Add(reference);
}
private static AssemblyReference FormatAssemblyReference(XElement reference)
{
var output = new AssemblyReference
{
Include = reference.Attribute("Include")?.Value
};
if (output.Include.Equals("Microsoft.CSharp", StringComparison.OrdinalIgnoreCase))
{
// This reference is obsolete.
return(null);
}
var specificVersion = reference.Descendants().FirstOrDefault(x => x.Name.LocalName == "SpecificVersion");
if (specificVersion != null)
{
output.SpecificVersion = specificVersion.Value;
}
var hintPath = reference.Descendants().FirstOrDefault(x => x.Name.LocalName == "HintPath");
if (hintPath != null)
{
output.HintPath = hintPath.Value;
}
var isPrivate = reference.Descendants().FirstOrDefault(x => x.Name.LocalName == "Private");
if (isPrivate != null)
{
output.Private = isPrivate.Value;
}
var embedInteropTypes = reference.Descendants().FirstOrDefault(x => x.Name.LocalName == "EmbedInteropTypes");
if (embedInteropTypes != null)
{
output.EmbedInteropTypes = embedInteropTypes.Value;
}
return(output);
}
private uint AddImplementation(IImplementation implementation)
{
if (implementation is null)
{
return(0);
}
var token = implementation switch
{
AssemblyReference assemblyReference => GetAssemblyReferenceToken(assemblyReference),
ExportedType exportedType => AddExportedType(exportedType),
FileReference fileReference => AddFileReference(fileReference),
_ => throw new ArgumentOutOfRangeException(nameof(implementation))
};
return(Metadata.TablesStream
.GetIndexEncoder(CodedIndex.Implementation)
.EncodeToken(token));
}
public GenericInstantiationTest()
{
_image = NetAssemblyFactory.CreateAssembly("SomeAssembly", true)
.NetDirectory.MetadataHeader.LockMetadata();
_importer = new ReferenceImporter(_image);
var scope = new AssemblyReference("SomeAssemblyRef", new Version(1, 2, 3, 4));
_typeArgs = new TypeSignature[] { _image.TypeSystem.String, _image.TypeSystem.Int32, _image.TypeSystem.Double };
_methodArgs = new TypeSignature[] { _image.TypeSystem.Byte, _image.TypeSystem.SByte, _image.TypeSystem.Object };
_context = new GenericContext(
new GenericInstanceTypeSignature(
new TypeReference(scope, "A.B.C", "M"),
_typeArgs),
new GenericInstanceMethodSignature(
_methodArgs));
}
protected virtual void LoadReferences(ProjectElement project, Hashtable projects, XmlDocument doc, string projectDir, string projectLangTag)
{
string lReferencesQuery = String.Format(STR_ReferencesQueryFormat, projectLangTag);
XmlNodeList lReferences = doc.SelectNodes(lReferencesQuery);
int lCount = lReferences.Count;
for (int i = 0; i < lCount; i++)
{
System.Xml.XmlNode lReferenceNode = lReferences[i];
System.Xml.XmlNode lName = lReferenceNode.Attributes.GetNamedItem(STR_Name);
System.Xml.XmlNode lAssemblyName = lReferenceNode.Attributes.GetNamedItem(STR_AssemblyName);
if (lAssemblyName != null)
{
string lAssemblyNameStr = lAssemblyName.Value;
string lPath = FrameworkHelper.GetAssemblyPath(lAssemblyNameStr);
if (lPath == null || lPath.Length == 0)
{
System.Xml.XmlNode lHintPath = lReferenceNode.Attributes.GetNamedItem("HintPath");
lPath = lHintPath.Value;
lPath = PathUtilities.GetPath(projectDir, lPath);
if (File.Exists(lPath))
{
AssemblyReference lRef = new AssemblyReference(lPath);
project.AddReference(lRef);
}
}
else
project.AddReferenceByName(lAssemblyNameStr);
}
else
{
System.Xml.XmlNode lProjectRef = lReferenceNode.Attributes.GetNamedItem(STR_Project);
string lGuid = lProjectRef.Value;
ProjectInfo lInfo = projects[lGuid] as ProjectInfo;
if (lInfo != null)
{
AssemblyReference lRef = new AssemblyReference(String.Empty);
lRef.SetSourceProjectFullName(lInfo.FilePath);
project.AddReference(lRef);
}
}
}
}
private AssemblyReference ReadAssemblyReferenceItem(ProjectItemElement element)
{
var reference = new AssemblyReference(element.Include);
if (element.HasMetadata)
{
foreach (var metadata in element.Metadata)
{
switch (metadata.Name)
{
case "SpecificVersion":
reference.SpecificVersion = bool.Parse(metadata.Value);
break;
case "HintPath":
reference.HintPath = metadata.Value;
break;
default:
throw new FormatException(string.Format("Invalid or unsupported metadata '{0}'.", metadata.Name));
}
}
}
return reference;
}
public TypeSystem(MetadataHeader header, bool isMsCorLib)
{
_header = header;
_isMsCorLib = isMsCorLib;
if (!isMsCorLib)
{
MsCorLibReference = header.GetStream<TableStream>().GetTable<AssemblyReference>().FirstOrDefault(x => x.Name == "mscorlib");
if (MsCorLibReference == null)
{
MsCorLibReference = new AssemblyReference(new ReflectionAssemblyNameWrapper(typeof(object).Assembly.GetName()))
{
Header = header,
Culture = "neutral",
Version = new Version(header.VersionString[1] - 48, 0, 0, 0)
};
}
}
Boolean = CreateSignature(ElementType.Boolean, "Boolean", true);
SByte = CreateSignature(ElementType.I1, "SByte", true);
Int16 = CreateSignature(ElementType.I2, "Int16", true);
Int32 = CreateSignature(ElementType.I4, "Int32", true);
Int64 = CreateSignature(ElementType.I8, "Int64", true);
IntPtr = CreateSignature(ElementType.I, "IntPtr", true);
Byte = CreateSignature(ElementType.U1, "Byte", true);
UInt16 = CreateSignature(ElementType.U2, "UInt16", true);
UInt32 = CreateSignature(ElementType.U4, "UInt32", true);
UInt64 = CreateSignature(ElementType.U8, "UInt64", true);
UIntPtr = CreateSignature(ElementType.U, "UIntPtr", true);
Single = CreateSignature(ElementType.R4, "Single", true);
Double = CreateSignature(ElementType.R8, "Double", true);
Object = CreateSignature(ElementType.Object, "Object", false);
Char = CreateSignature(ElementType.Char, "Char", true);
String = CreateSignature(ElementType.String, "String", false);
Type = CreateSignature(ElementType.Type, "Type", false);
TypedReference = CreateSignature(ElementType.TypedByRef, "TypedReference", true);
Void = CreateSignature(ElementType.Void, "Void", true);
}
private int Startup(IEnumerable<string> args)
{
var options = args.Where(each => each.StartsWith("--")).Switches();
var parameters = args.Parameters();
foreach (var arg in options.Keys) {
var argumentParameters = options[arg];
switch (arg) {
/* global switches */
case "load-config":
// all ready done, but don't get too picky.
break;
case "nologo":
this.Assembly().SetLogo(string.Empty);
break;
case "help":
return Help();
case "certificate-path":
var cert = argumentParameters.Last();
_signingCertPath = _signingCertPath.IndexOf(":") > 1 ? cert : Path.GetFullPath(argumentParameters.Last());
break;
case "password":
_signingCertPassword = argumentParameters.Last();
break;
case "remember":
_remember = true;
break;
case "auto":
break;
case "sign":
_sign = true;
break;
case "just-sign":
_sign = true;
_justsign = true;
break;
case "strong-name":
_strongname = true;
break;
case "verbose":
_verbose = true;
break;
case "company":
_company = argumentParameters.Last();
break;
case "description":
_description = argumentParameters.Last();
break;
case "internal-name":
_internalName = argumentParameters.Last();
break;
case "copyright":
_copyright = argumentParameters.Last();
break;
case "original-filename":
_originalFilename = argumentParameters.Last();
break;
case "product-name":
_productName = argumentParameters.Last();
break;
case "verify":
_verify = true;
break;
case "reference-assembly":
foreach (var asmRef in argumentParameters) {
if (string.IsNullOrEmpty(asmRef)) {
return Fail("Missing assembly information for --assembly-reference.");
}
var parts = asmRef.Split(", ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
var assemblyref = new AssemblyReference {Name = parts[0]};
foreach (var part in parts.Skip(1)) {
var kp = part.Split("= ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
if (kp.Length != 2) {
return Fail("Invalid option '{0}' in assembly reference '{1}'.", part, asmRef);
}
switch (kp[0].ToLower()) {
case "version":
case "ver":
assemblyref.Version = kp[1];
if (assemblyref.Version == 0L) {
return Fail("Invalid Version '{0}' in assembly reference '{1}'.", kp[1], asmRef);
}
break;
case "publickeytoken":
case "pkt":
case "token":
if (kp[1].Length != 16) {
return Fail("Invalid publicKeyToken '{0}' in assembly reference '{1}'.", kp[1], asmRef);
}
assemblyref.PublicKeyToken = kp[1];
break;
case "processorarchitecture":
case "architecture":
case "arch":
assemblyref.Architecture = kp[1];
if (assemblyref.Architecture == Architecture.Auto || assemblyref.Architecture == Architecture.Unknown) {
return Fail("Invalid processorArchitecture '{0}' in assembly reference '{1}'.", kp[1], asmRef);
}
break;
}
}
if (assemblyref.Version == 0 || assemblyref.Architecture == Architecture.Unknown || string.IsNullOrEmpty(assemblyref.PublicKeyToken)) {
return Fail("Invalid assembly reference '{0}' ", asmRef);
}
assemblyReferences.Add(assemblyref);
}
break;
case "product-version":
_productVersion = argumentParameters.Last();
if (_productVersion == 0L) {
return Fail("--product-version must be in the form ##.##.##.##");
}
break;
case "file-version":
_fileVersion = argumentParameters.Last();
if (_fileVersion == 0L) {
return Fail("--file-version must be in the form ##.##.##.##");
}
break;
case "execution-level":
switch (argumentParameters.Last()) {
case "administrator":
case "admin":
case "requires-admin":
case "requiresadmin":
case "requiresadministrator":
case "requires-administrator":
_executionLevel = ExecutionLevel.requireAdministrator;
break;
case "invoker":
case "asinvoker":
case "as-invoker":
_executionLevel = ExecutionLevel.asInvoker;
break;
case "highest-available":
case "highest":
case "highestavailable":
_executionLevel = ExecutionLevel.highestAvailable;
break;
}
break;
case "dpi-aware":
if (argumentParameters.Last().IsTrue()) {
_dpiAware = true;
}
if (argumentParameters.Last().IsFalse()) {
_dpiAware = false;
}
break;
default:
return Fail("Unknown parameter [--{0}]", arg);
}
}
Logo();
if (_verify) {
// return Verify(parameters);
}
if (string.IsNullOrEmpty(_signingCertPath)) {
_certificate = CertificateReference.Default;
if (_certificate == null) {
return Fail("No default certificate stored in the registry");
}
} else if (string.IsNullOrEmpty(_signingCertPassword)) {
_certificate = new CertificateReference(_signingCertPath);
} else {
_certificate = new CertificateReference(_signingCertPath, _signingCertPassword);
}
using (new ConsoleColors(ConsoleColor.White, ConsoleColor.Black)) {
Verbose("Loaded certificate with private key {0}", _certificate.Location);
}
if (_remember) {
Verbose("Storing certificate details in the registry.");
_certificate.RememberPassword();
CertificateReference.Default = _certificate;
}
if (parameters.Count() < 1) {
return Fail("Missing files to sign/name. \r\n\r\n Use --help for command line help.");
}
var tasks = new List<Task>();
if (_company != null && _company.Equals("auto", StringComparison.CurrentCultureIgnoreCase)) {
_company = _certificate.CommonName;
}
var failures = 0;
try {
var allFiles = parameters.FindFilesSmarter().ToArray();
var origMD5 = new XDictionary<string, string>();
var loading = allFiles.Select(each =>
Binary.Load(each,
BinaryLoadOptions.PEInfo |
BinaryLoadOptions.VersionInfo |
BinaryLoadOptions.Managed |
BinaryLoadOptions.Resources |
BinaryLoadOptions.Manifest |
BinaryLoadOptions.UnsignedManagedDependencies |
BinaryLoadOptions.MD5).ContinueWith(antecedent => {
lock (allFiles) {
if (antecedent.IsFaulted) {
Console.WriteLine("Failed to load file '{0}'", each);
var e = antecedent.Exception.Flatten().InnerExceptions.First();
Console.WriteLine("{0}--{1}", e.Message, e.StackTrace);
return;
}
try {
var binary = antecedent.Result;
origMD5.Add(each, binary.MD5);
if (binary.IsPEFile && !_justsign) {
// do PE file stuff
if (_sign) {
binary.SigningCertificate = _certificate;
}
if (binary.IsManaged && _strongname) {
binary.StrongNameKeyCertificate = _certificate;
}
if (!assemblyReferences.IsNullOrEmpty()) {
foreach (var asmRef in assemblyReferences) {
binary.Manifest.Value.AddDependency(asmRef.Name, asmRef.Version, asmRef.Architecture, asmRef.PublicKeyToken);
}
}
if (_company != null) {
binary.CompanyName = _company;
}
if (_description != null) {
binary.FileDescription = _description;
}
if (_internalName != null) {
binary.InternalName = _internalName;
}
if (_copyright != null) {
binary.LegalCopyright = _copyright;
}
if (_originalFilename != null) {
binary.OriginalFilename = _originalFilename;
}
if (_productName != null) {
binary.ProductName = _productName;
}
if (_productVersion != 0) {
binary.ProductVersion = _productVersion;
}
if (_fileVersion != 0) {
binary.FileVersion = _fileVersion;
}
if (_dpiAware != null) {
binary.Manifest.Value.DpiAware = _dpiAware == true;
}
if (_executionLevel != ExecutionLevel.none) {
binary.Manifest.Value.RequestedExecutionLevel = _executionLevel;
}
} else {
// do stuff for non-pe files
// we can try to apply a signature, and that's about it.
if (_sign) {
binary.SigningCertificate = _certificate;
}
}
binary.Save().Wait();
} catch (Exception e) {
while (e.GetType() == typeof (AggregateException)) {
e = (e as AggregateException).Flatten().InnerExceptions[0];
}
failures += Fail("{0}--{1}", e.Message, e.StackTrace);
}
}
}, TaskContinuationOptions.AttachedToParent)).ToArray();
// Thread.Sleep(1000);
// wait for loading.
return Task.Factory.ContinueWhenAll(loading, tsks => {
Console.WriteLine("Done {0} files", tsks.Length);
(from each in Binary.Files
select new {
Filename = Path.GetFileName(each.Filename),
Original_MD5 = origMD5[each.Filename],
New_MD5 = each.MD5,
// Status = each.Message,
}).ToTable().ConsoleOut();
if (failures > 0) {
Console.WriteLine("*** Bad News. Failed. *** ");
}
if (Binary.IsAnythingStillLoading) {
Console.WriteLine("\r\n==== Uh, stuff is still in the loading state?! ====\r\n");
}
return failures;
}).Result;
} catch (Exception e) {
Console.WriteLine("{0}--{1}", e.Message, e.StackTrace);
return Fail("not good.");
}
}
private bool IsDependencyCircular(KeyValuePair<Tuple<SemanticVersion, string>, DllReference> mainAssembly, AssemblyReference dependency)
{
foreach (var circularDef in _configurationService.Get().CircularMapping)
{
if (circularDef.Item1.Equals(mainAssembly.Value.Id.Item2) &&
circularDef.Item2.Item1.Equals(dependency.Item2))
{
Trace.TraceWarning($"Circular dependency detected between {mainAssembly.Key.Item2} and {dependency.Item2}");
return true;
}
}
return false;
}
// Caller should lock peFileToObjectModel
internal CoreTypes(PEFileToObjectModel peFileToObjectModel) {
INameTable nameTable = peFileToObjectModel.NameTable;
PEFileReader peFileReader = peFileToObjectModel.PEFileReader;
PeReader peReader = peFileToObjectModel.ModuleReader;
Module module = peFileToObjectModel.Module;
AssemblyIdentity/*?*/ assemblyIdentity = module.ModuleIdentity as AssemblyIdentity;
//This does more than just initialize the five types exposed above, since it is also
//necessary to initialize any typedefs and typerefs to types with short forms
//in such a way that they have the correct type codes.
int systemName = nameTable.System.UniqueKey;
int voidName = nameTable.Void.UniqueKey;
int booleanName = nameTable.Boolean.UniqueKey;
int charName = nameTable.Char.UniqueKey;
int byteName = nameTable.Byte.UniqueKey;
int sByteName = nameTable.SByte.UniqueKey;
int int16Name = nameTable.Int16.UniqueKey;
int uint16Name = nameTable.UInt16.UniqueKey;
int int32Name = nameTable.Int32.UniqueKey;
int uint32Name = nameTable.UInt32.UniqueKey;
int int64Name = nameTable.Int64.UniqueKey;
int uint64Name = nameTable.UInt64.UniqueKey;
int stringName = nameTable.String.UniqueKey;
int intPtrName = nameTable.IntPtr.UniqueKey;
int uintPtrName = nameTable.UIntPtr.UniqueKey;
int objectName = nameTable.Object.UniqueKey;
int singleName = nameTable.Single.UniqueKey;
int doubleName = nameTable.Double.UniqueKey;
int decimalName = nameTable.Decimal.UniqueKey;
int typedReference = nameTable.TypedReference.UniqueKey;
int enumName = nameTable.Enum.UniqueKey;
int valueTypeName = nameTable.ValueType.UniqueKey;
int multicastDelegateName = nameTable.MulticastDelegate.UniqueKey;
int typeName = nameTable.Type.UniqueKey;
int arrayName = nameTable.Array.UniqueKey;
int paramArrayAttributeName = peReader.ParamArrayAttribute.UniqueKey;
if (assemblyIdentity != null && assemblyIdentity.Equals(peReader.metadataReaderHost.CoreAssemblySymbolicIdentity)) {
peReader.RegisterCoreAssembly(module as Assembly);
uint numberOfTypeDefs = peFileReader.TypeDefTable.NumberOfRows;
for (uint i = 1; i <= numberOfTypeDefs; ++i) {
TypeDefRow typeDefRow = peFileReader.TypeDefTable[i];
if (!typeDefRow.IsNested) {
int namespaceName = peFileToObjectModel.GetNameFromOffset(typeDefRow.Namespace).UniqueKey;
if (namespaceName == systemName) {
int typeDefName = peFileToObjectModel.GetNameFromOffset(typeDefRow.Name).UniqueKey;
if (typeDefName == voidName)
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Void);
else if (typeDefName == booleanName)
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Boolean);
else if (typeDefName == charName)
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Char);
else if (typeDefName == byteName)
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Byte);
else if (typeDefName == sByteName)
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.SByte);
else if (typeDefName == int16Name)
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Int16);
else if (typeDefName == uint16Name)
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt16);
else if (typeDefName == int32Name)
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Int32);
else if (typeDefName == uint32Name)
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt32);
else if (typeDefName == int64Name)
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Int64);
else if (typeDefName == uint64Name)
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt64);
else if (typeDefName == stringName)
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.String);
else if (typeDefName == intPtrName)
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.IntPtr);
else if (typeDefName == uintPtrName)
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.UIntPtr);
else if (typeDefName == objectName)
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Object);
else if (typeDefName == singleName)
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Single);
else if (typeDefName == doubleName)
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.Double);
else if (typeDefName == typedReference)
peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.TypedReference);
else if (typeDefName == enumName)
this.SystemEnum = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
else if (typeDefName == valueTypeName)
this.SystemValueType = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
else if (typeDefName == multicastDelegateName)
this.SystemMulticastDelegate = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
else if (typeDefName == typeName)
this.SystemType = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
else if (typeDefName == paramArrayAttributeName)
this.SystemParamArrayAttribute = peFileToObjectModel.GetPredefinedTypeDefinitionAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
}
}
} else {
uint numberOfTypeRefs = peFileReader.TypeRefTable.NumberOfRows;
AssemblyReference/*?*/ coreAssemblyRef = peFileToObjectModel.FindAssemblyReference(peFileToObjectModel.CoreAssemblySymbolicIdentity);
if (coreAssemblyRef == null) {
// Error...
coreAssemblyRef = new AssemblyReference(peFileToObjectModel, 1, peFileToObjectModel.CoreAssemblySymbolicIdentity, AssemblyFlags.Retargetable);
}
uint coreAssemblyRefToken = coreAssemblyRef.TokenValue;
for (uint i = 1; i <= numberOfTypeRefs; ++i) {
TypeRefRow typeRefRow = peFileReader.TypeRefTable[i];
if (typeRefRow.ResolutionScope != coreAssemblyRefToken)
continue;
int namespaceName = peFileToObjectModel.GetNameFromOffset(typeRefRow.Namespace).UniqueKey;
if (namespaceName == systemName) {
int typeDefName = peFileToObjectModel.GetNameFromOffset(typeRefRow.Name).UniqueKey;
if (typeDefName == voidName)
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Void);
else if (typeDefName == booleanName)
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Boolean);
else if (typeDefName == charName)
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Char);
else if (typeDefName == byteName)
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Byte);
else if (typeDefName == sByteName)
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.SByte);
else if (typeDefName == int16Name)
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Int16);
else if (typeDefName == uint16Name)
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt16);
else if (typeDefName == int32Name)
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Int32);
else if (typeDefName == uint32Name)
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt32);
else if (typeDefName == int64Name)
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Int64);
else if (typeDefName == uint64Name)
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.UInt64);
else if (typeDefName == stringName)
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.String);
else if (typeDefName == intPtrName)
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.IntPtr);
else if (typeDefName == uintPtrName)
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.UIntPtr);
else if (typeDefName == objectName)
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Object);
else if (typeDefName == singleName)
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Single);
else if (typeDefName == doubleName)
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.Double);
else if (typeDefName == typedReference)
peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.TypedReference);
else if (typeDefName == enumName)
this.SystemEnum = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
else if (typeDefName == valueTypeName)
this.SystemValueType = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
else if (typeDefName == multicastDelegateName)
this.SystemMulticastDelegate = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
else if (typeDefName == typeName)
this.SystemType = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
else if (typeDefName == paramArrayAttributeName)
this.SystemParamArrayAttribute = peFileToObjectModel.GetPredefinedTypeRefReferenceAtRowWorker(i, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
}
NamespaceReference systemNSR = peFileToObjectModel.GetNamespaceReferenceForString(coreAssemblyRef, nameTable.System);
if (this.SystemEnum == null || (peFileToObjectModel.SystemEnumAssembly != null && coreAssemblyRef != peFileToObjectModel.SystemEnumAssembly))
this.SystemEnum = peFileToObjectModel.typeCache.CreateCoreTypeReference(peFileToObjectModel.SystemEnumAssembly??coreAssemblyRef, systemNSR, nameTable.Enum, MetadataReaderSignatureTypeCode.NotModulePrimitive);
if (this.SystemValueType == null || (peFileToObjectModel.SystemValueTypeAssembly != null && coreAssemblyRef != peFileToObjectModel.SystemValueTypeAssembly))
this.SystemValueType = peFileToObjectModel.typeCache.CreateCoreTypeReference(peFileToObjectModel.SystemValueTypeAssembly??coreAssemblyRef, systemNSR, nameTable.ValueType, MetadataReaderSignatureTypeCode.NotModulePrimitive);
if (this.SystemMulticastDelegate == null || (peFileToObjectModel.SystemMulticastDelegateAssembly != null && coreAssemblyRef != peFileToObjectModel.SystemMulticastDelegateAssembly))
this.SystemMulticastDelegate = peFileToObjectModel.typeCache.CreateCoreTypeReference(peFileToObjectModel.SystemMulticastDelegateAssembly??coreAssemblyRef, systemNSR, nameTable.MulticastDelegate, MetadataReaderSignatureTypeCode.NotModulePrimitive);
if (this.SystemType == null || (peFileToObjectModel.SystemTypeAssembly != null && coreAssemblyRef != peFileToObjectModel.SystemTypeAssembly))
this.SystemType = peFileToObjectModel.typeCache.CreateCoreTypeReference(peFileToObjectModel.SystemTypeAssembly??coreAssemblyRef, systemNSR, nameTable.Type, MetadataReaderSignatureTypeCode.NotModulePrimitive);
if (this.SystemParamArrayAttribute == null || (peFileToObjectModel.SystemParamArrayAttributeAssembly != null && coreAssemblyRef != peFileToObjectModel.SystemParamArrayAttributeAssembly))
this.SystemParamArrayAttribute = peFileToObjectModel.typeCache.CreateCoreTypeReference(peFileToObjectModel.SystemParamArrayAttributeAssembly??coreAssemblyRef, systemNSR, peReader.ParamArrayAttribute, MetadataReaderSignatureTypeCode.NotModulePrimitive);
}
}
public List<string> GetAssemblyPaths()
{
// Perform a topological sort to get the list of assemblies in order
// to cause loading of dependencies to happen before an assembly
// that references them.
List<AssemblyReference> references = new List<AssemblyReference>();
Dictionary<string, AssemblyReference> referenceMap =
new Dictionary<string, AssemblyReference>(StringComparer.Ordinal);
foreach (KeyValuePair<string, AssemblyDefinition> assembly in _assemblies) {
AssemblyReference reference = new AssemblyReference(assembly.Key, assembly.Value);
references.Add(reference);
referenceMap[reference.FullName] = reference;
}
List<AssemblyReference> sortedReferences = new List<AssemblyReference>();
references.ForEach(r => VisitReference(r, referenceMap, sortedReferences));
return sortedReferences.Select(r => r.Path).ToList();
}
private void SerializeAssemblyReference(AssemblyReference def)
{
if (def == null) return;
XmlAttribute att = Document.CreateAttribute("assembly");
att.Value = def.AssemblyName;
Current.Attributes.Append( att );
}
public virtual AssemblyReference VisitAssemblyReference(AssemblyReference assemblyReference){
return assemblyReference;
}
public override AssemblyReference VisitAssemblyReference(AssemblyReference assemblyReference)
{
throw new ApplicationException("unimplemented");
}
private IAssemblyReference ParseAssemblyReference(string value, IAssemblyManager assemblyManager)
{
string[] assemblyNameParts = this.assembly.Split(new char[] { ':' });
IAssembly assembly = new Assembly();
assembly.AssemblyManager = assemblyManager;
IModule module = new Module();
module.Assembly = assembly;
IAssemblyReference assemblyReference = new AssemblyReference();
assemblyReference.Context = module;
assemblyReference.Name = assemblyNameParts[0];
assemblyReference.Version = ((assemblyNameParts.Length > 1) && (assemblyNameParts[1].Length > 0)) ? new Version(assemblyNameParts[1]) : new Version(0, 0, 0, 0);
assemblyReference.PublicKeyToken = ((assemblyNameParts.Length > 2) && (assemblyNameParts[2].Length > 0)) ? ParseByteArray(assemblyNameParts[2]) : new byte[0];
assemblyReference.Culture = ((assemblyNameParts.Length > 3) && (assemblyNameParts[3].Length > 0)) ? assemblyNameParts[3] : string.Empty;
return assemblyReference;
}
internal Microsoft.Cci.IAssemblyReference Translate(AssemblySymbol assembly)
{
if (ReferenceEquals(sourceModule.ContainingAssembly, assembly))
{
return (Microsoft.Cci.IAssemblyReference)this;
}
object reference;
if (SymbolsMap.TryGetValue(assembly, out reference))
{
return (Microsoft.Cci.IAssemblyReference)reference;
}
AssemblyReference asmRef = new AssemblyReference(assembly);
SymbolsMap.Add(assembly, asmRef);
SymbolsMap.Add(assembly.Modules[0], asmRef);
return asmRef;
}
internal Microsoft.Cci.IModuleReference Translate(ModuleSymbol module)
{
if (ReferenceEquals(sourceModule, module))
{
return this;
}
object reference;
if (SymbolsMap.TryGetValue(module, out reference))
{
return (Microsoft.Cci.IModuleReference)reference;
}
Microsoft.Cci.IModuleReference moduleRef;
AssemblySymbol container = module.ContainingAssembly;
if (container != null && ReferenceEquals(container.Modules[0], module))
{
moduleRef = new AssemblyReference(container);
SymbolsMap.Add(container, moduleRef);
}
else
{
moduleRef = new ModuleReference(this, module);
}
SymbolsMap.Add(module, moduleRef);
return moduleRef;
}
public virtual Differences VisitAssemblyReference(AssemblyReference/*!*/ assemblyReference1, AssemblyReference assemblyReference2) {
Differences differences = new Differences(assemblyReference1, assemblyReference2);
if (assemblyReference1 == null || assemblyReference2 == null){
if (assemblyReference1 != assemblyReference2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
AddressDereference changes = (AddressDereference)assemblyReference2.Clone();
AddressDereference deletions = (AddressDereference)assemblyReference2.Clone();
AddressDereference insertions = (AddressDereference)assemblyReference2.Clone();
if (assemblyReference1.Culture == assemblyReference2.Culture) differences.NumberOfSimilarities++; else differences.NumberOfDifferences++;
if (assemblyReference1.Flags == assemblyReference2.Flags) differences.NumberOfSimilarities++; else differences.NumberOfDifferences++;
if (assemblyReference1.Name == assemblyReference2.Name) differences.NumberOfSimilarities++; else differences.NumberOfDifferences++;
if (this.ValuesAreEqual(assemblyReference1.PublicKeyOrToken, assemblyReference2.PublicKeyOrToken)) differences.NumberOfSimilarities++; else differences.NumberOfDifferences++;
if (assemblyReference1.Version == assemblyReference2.Version) differences.NumberOfSimilarities++; else differences.NumberOfDifferences++;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
/// <summary>
/// Populates the list of assembly references.
/// </summary>
void LoadAssemblyReferences()
//^ ensures this.AssemblyReferenceArray != null;
{
uint numberOfAssemblyReferences = this.PEFileReader.AssemblyRefTable.NumberOfRows;
AssemblyReference[] assemblyRefList = new AssemblyReference[numberOfAssemblyReferences + 1];
for (uint i = 1; i <= numberOfAssemblyReferences; ++i) {
AssemblyRefRow assemblyRefRow = this.PEFileReader.AssemblyRefTable[i];
IName assemblyRefName = this.GetNameFromOffset(assemblyRefRow.Name);
IName cultureName = this.GetNameFromOffset(assemblyRefRow.Culture);
Version version = new Version(assemblyRefRow.MajorVersion, assemblyRefRow.MinorVersion, assemblyRefRow.BuildNumber, assemblyRefRow.RevisionNumber);
byte[] publicKeyTokenArray = TypeCache.EmptyByteArray;
if (assemblyRefRow.PublicKeyOrToken != 0) {
var publicKeyOrTokenArray = this.PEFileReader.BlobStream[assemblyRefRow.PublicKeyOrToken];
if ((assemblyRefRow.Flags & AssemblyFlags.PublicKey) == AssemblyFlags.PublicKey && publicKeyOrTokenArray.Length > 0) {
publicKeyTokenArray = UnitHelper.ComputePublicKeyToken(publicKeyOrTokenArray);
} else {
publicKeyTokenArray = publicKeyOrTokenArray;
}
if (publicKeyTokenArray.Length != 8) {
// Error
}
}
AssemblyIdentity assemblyIdentity = new AssemblyIdentity(assemblyRefName, cultureName.Value, version, publicKeyTokenArray, string.Empty);
AssemblyReference assemblyReference = new AssemblyReference(this, i, assemblyIdentity, assemblyRefRow.Flags);
assemblyRefList[i] = assemblyReference;
}
//^ NonNullType.AssertInitialized(assemblyRefList);
this.AssemblyReferenceArray = assemblyRefList;
}
public async Task<AssemblyReference[]> ResolveAssemblyReferences (ProjectConfigurationInfo[] configurations, CancellationToken cancellationToken)
{
AssemblyReference[] refs = null;
var id = configurations [0].Configuration + "|" + configurations [0].Platform;
using (await referenceCacheLock.EnterAsync ()) {
// Check the cache before starting the task
if (referenceCache.TryGetValue (id, out refs))
return refs;
}
// Get an id for the task, it will be used later on to cancel the task if necessary
var taskId = Interlocked.Increment (ref lastTaskId);
IDisposable cr = null;
refs = await Task.Run (async () => {
using (await referenceCacheLock.EnterAsync ()) {
// Check again the cache, maybe the value was set while the task was starting
if (referenceCache.TryGetValue (id, out refs))
return refs;
// Get ready to cancel the task if the cancellation token is signalled
cr = RegisterCancellation (cancellationToken, taskId);
MSBuildResult result;
bool locked = false;
try {
BeginOperation ();
locked = await engine.Semaphore.WaitAsync (Timeout.Infinite, cancellationToken).ConfigureAwait (false);
// FIXME: This lock should not be necessary, but remoting seems to have problems when doing many concurrent calls.
result = builder.Run (
configurations, null, MSBuildVerbosity.Normal,
new [] { "ResolveAssemblyReferences" }, new [] { "ReferencePath" }, null, null, taskId
);
} catch (Exception ex) {
CheckDisconnected ();
LoggingService.LogError ("ResolveAssemblyReferences failed", ex);
return new AssemblyReference [0];
} finally {
if (locked)
engine.Semaphore.Release ();
EndOperation ();
}
List<MSBuildEvaluatedItem> items;
if (result.Items.TryGetValue ("ReferencePath", out items) && items != null) {
string aliases;
refs = items.Select (i => new AssemblyReference (i.ItemSpec, i.Metadata.TryGetValue ("Aliases", out aliases) ? aliases : "")).ToArray ();
} else
refs = new AssemblyReference [0];
referenceCache [id] = refs;
}
return refs;
});
// Dispose the cancel registration
if (cr != null)
cr.Dispose ();
return refs;
}
// Caller should lock this.
internal Assembly/*?*/ ResolveAssemblyRefReference(
AssemblyReference assemblyReference
) {
Assembly/*?*/ assem = this.ModuleReader.LookupAssembly(this.Module, assemblyReference.UnifiedAssemblyIdentity);
return assem;
}
private void F(AssemblyReference[] r)
{
Console.WriteLine(r);
}
private void VisitReference(AssemblyReference reference, Dictionary<string, AssemblyReference> referenceMap, List<AssemblyReference> referenceList)
{
if (reference.Visited) {
return;
}
reference.Visit();
foreach (string dependencyName in reference.Dependencies) {
AssemblyReference dependencyReference;
if (referenceMap.TryGetValue(dependencyName, out dependencyReference)) {
VisitReference(dependencyReference, referenceMap, referenceList);
}
}
referenceList.Add(reference);
}
public virtual AssemblyReference VisitAssemblyReference(AssemblyReference assemblyReference, AssemblyReference changes, AssemblyReference deletions, AssemblyReference insertions){
this.UpdateSourceContext(assemblyReference, changes);
if (assemblyReference == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
assemblyReference.Culture = changes.Culture;
assemblyReference.Flags = changes.Flags;
assemblyReference.Name = changes.Name;
assemblyReference.PublicKeyOrToken = changes.PublicKeyOrToken;
assemblyReference.Version = changes.Version;
}
}else if (deletions != null)
return null;
return assemblyReference;
}
public override AssemblyReference VisitAssemblyReference(AssemblyReference assemblyReference)
{
if (assemblyReference == null) return null;
return base.VisitAssemblyReference((AssemblyReference)assemblyReference.Clone());
}
