AssemblyInformation.cs

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
#if !FEATURE_ASSEMBLYLOADCONTEXT
using System.Linq;
using System.Runtime.InteropServices;
#endif
using System.Reflection;
using System.Runtime.Versioning;
using System.Text;
using Microsoft.Build.Shared;
using Microsoft.Build.Shared.FileSystem;
#if FEATURE_ASSEMBLYLOADCONTEXT
using System.Reflection.PortableExecutable;
using System.Reflection.Metadata;
#endif
using Microsoft.Build.Tasks.AssemblyDependency;

#nullable disable

using Microsoft.Build.Framework;
namespace Microsoft.Build.Tasks
{
    /// <summary>
    /// Collection of methods used to discover assembly metadata.
    /// Primarily stolen from manifestutility.cs AssemblyMetaDataImport class.
    /// </summary>
    internal class AssemblyInformation : DisposableBase
    {
        private AssemblyNameExtension[] _assemblyDependencies;
        private string[] _assemblyFiles;
#if !FEATURE_ASSEMBLYLOADCONTEXT
        private readonly IMetaDataDispenser _metadataDispenser;
        private readonly IMetaDataAssemblyImport _assemblyImport;
        private static Guid s_importerGuid = new Guid(((GuidAttribute)Attribute.GetCustomAttribute(typeof(IMetaDataImport), typeof(GuidAttribute), false)).Value);
        private readonly Assembly _assembly;
#endif
        private readonly string _sourceFile;
        private FrameworkName _frameworkName;

#if FEATURE_ASSEMBLYLOADCONTEXT
        private bool _metadataRead;
#endif

#if !FEATURE_ASSEMBLYLOADCONTEXT
        private const string s_targetFrameworkAttribute = "System.Runtime.Versioning.TargetFrameworkAttribute";
#endif
#if !FEATURE_ASSEMBLYLOADCONTEXT
        // Borrowed from genman.
        private const int GENMAN_STRING_BUF_SIZE = 1024;
        private const int GENMAN_LOCALE_BUF_SIZE = 64;
        private const int GENMAN_ENUM_TOKEN_BUF_SIZE = 16; // 128 from genman seems too big.

        static AssemblyInformation()
        {
            AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += ReflectionOnlyAssemblyResolve;
        }
#endif // FEATURE_ASSEMBLY_LOADFROM

        /// <summary>
        /// Construct an instance for a source file.
        /// </summary>
        /// <param name="sourceFile">The assembly.</param>
        internal AssemblyInformation(string sourceFile)
        {
            // Extra checks for PInvoke-destined data.
            ErrorUtilities.VerifyThrowArgumentNull(sourceFile);
            _sourceFile = sourceFile;

#if !FEATURE_ASSEMBLYLOADCONTEXT
            if (NativeMethodsShared.IsWindows)
            {
                // Create the metadata dispenser and open scope on the source file.
                _metadataDispenser = (IMetaDataDispenser)new CorMetaDataDispenser();
                _assemblyImport = (IMetaDataAssemblyImport)_metadataDispenser.OpenScope(sourceFile, 0, ref s_importerGuid);
            }
            else
            {
                _assembly = Assembly.ReflectionOnlyLoadFrom(sourceFile);
            }
#endif
        }

#if !FEATURE_ASSEMBLYLOADCONTEXT
        private static Assembly ReflectionOnlyAssemblyResolve(object sender, ResolveEventArgs args)
        {
            string[] nameParts = args.Name.Split(MSBuildConstants.CommaChar);
            Assembly assembly = null;

            if (args.RequestingAssembly != null && !string.IsNullOrEmpty(args.RequestingAssembly.Location) && nameParts.Length > 0)
            {
                var location = args.RequestingAssembly.Location;
                var newLocation = Path.Combine(Path.GetDirectoryName(location), nameParts[0].Trim() + ".dll");

                try
                {
                    if (FileSystems.Default.FileExists(newLocation))
                    {
                        assembly = Assembly.ReflectionOnlyLoadFrom(newLocation);
                    }
                }
                catch
                {
                }
            }

            // Let's try to automatically load it
            if (assembly == null)
            {
                try
                {
                    assembly = Assembly.ReflectionOnlyLoad(args.Name);
                }
                catch
                {
                }
            }

            return assembly;
        }
#endif

        /// <summary>
        /// Get the dependencies.
        /// </summary>
        /// <value></value>
        public AssemblyNameExtension[] Dependencies
        {
            get
            {
                if (_assemblyDependencies == null)
                {
                    lock (this)
                    {
                        if (_assemblyDependencies == null)
                        {
                            _assemblyDependencies = ImportAssemblyDependencies();
                        }
                    }
                }

                return _assemblyDependencies;
            }
        }

        /// <summary>
        /// Get the scatter files from the assembly metadata.
        /// </summary>
        public string[] Files
        {
            get
            {
                if (_assemblyFiles == null)
                {
                    lock (this)
                    {
                        if (_assemblyFiles == null)
                        {
                            _assemblyFiles = ImportFiles();
                        }
                    }
                }

                return _assemblyFiles;
            }
        }

        /// <summary>
        /// What was the framework name that the assembly was built against.
        /// </summary>
        public FrameworkName FrameworkNameAttribute
        {
            get
            {
                if (_frameworkName == null)
                {
                    lock (this)
                    {
                        if (_frameworkName == null)
                        {
                            _frameworkName = GetFrameworkName();
                        }
                    }
                }

                return _frameworkName;
            }
        }

        /// <summary>
        /// Given an assembly name, crack it open and retrieve the list of dependent
        /// assemblies and  the list of scatter files.
        /// </summary>
        /// <param name="path">Path to the assembly.</param>
        /// <param name="assemblyMetadataCache">Cache of pre-extracted assembly metadata.</param>
        /// <param name="dependencies">Receives the list of dependencies.</param>
        /// <param name="scatterFiles">Receives the list of associated scatter files.</param>
        /// <param name="frameworkName">Gets the assembly name.</param>
        internal static void GetAssemblyMetadata(
            string path,
            ConcurrentDictionary<string, AssemblyMetadata> assemblyMetadataCache,
            out AssemblyNameExtension[] dependencies,
            out string[] scatterFiles,
            out FrameworkName frameworkName)
        {
            var import = assemblyMetadataCache?.GetOrAdd(path, p => new AssemblyMetadata(p))
                ?? new AssemblyMetadata(path);

            dependencies = import.Dependencies;
            frameworkName = import.FrameworkName;
            scatterFiles = import.ScatterFiles;
        }

        /// <summary>
        /// Given an assembly name, crack it open and retrieve the TargetFrameworkAttribute
        /// assemblies and  the list of scatter files.
        /// </summary>
        internal static FrameworkName GetTargetFrameworkAttribute(string path)
        {
            using (var import = new AssemblyInformation(path))
            {
                return import.FrameworkNameAttribute;
            }
        }

        /// <summary>
        /// Determine if an file is a winmd file or not.
        /// </summary>
        internal static bool IsWinMDFile(
            string fullPath,
            GetAssemblyRuntimeVersion getAssemblyRuntimeVersion,
            FileExists fileExists,
            out string imageRuntimeVersion,
            out bool isManagedWinmd)
        {
            imageRuntimeVersion = String.Empty;
            isManagedWinmd = false;

            if (!NativeMethodsShared.IsWindows)
            {
                return false;
            }

            // May be null or empty is the file was never resolved to a path on disk.
            if (!String.IsNullOrEmpty(fullPath) && fileExists(fullPath))
            {
                imageRuntimeVersion = getAssemblyRuntimeVersion(fullPath);
                if (!String.IsNullOrEmpty(imageRuntimeVersion))
                {
                    bool containsWindowsRuntime = imageRuntimeVersion.IndexOf(
                        "WindowsRuntime",
                        StringComparison.OrdinalIgnoreCase) >= 0;

                    if (containsWindowsRuntime)
                    {
                        isManagedWinmd = imageRuntimeVersion.IndexOf("CLR", StringComparison.OrdinalIgnoreCase) >= 0;
                        return true;
                    }
                }
            }

            return false;
        }

#if !FEATURE_ASSEMBLYLOADCONTEXT
        /// <summary>
        /// Collects the metadata and attributes for specified assembly.
        /// The requested properties are used by legacy project system.
        /// </summary>
        internal AssemblyAttributes GetAssemblyMetadata()
        {
            IntPtr asmMetaPtr = IntPtr.Zero;
            ASSEMBLYMETADATA asmMeta = new();
            try
            {
                IMetaDataImport2 import2 = (IMetaDataImport2)_assemblyImport;
                _assemblyImport.GetAssemblyFromScope(out uint assemblyScope);

                // get the assembly, if there is no assembly, it is a module reference
                if (assemblyScope == 0)
                {
                    return null;
                }

                AssemblyAttributes assemblyAttributes = new()
                {
                    AssemblyFullPath = _sourceFile,
                    IsAssembly = true,
                };

                // will be populated with the assembly name
                char[] defaultCharArray = new char[GENMAN_STRING_BUF_SIZE];
                asmMetaPtr = AllocAsmMeta();
                _assemblyImport.GetAssemblyProps(
                    assemblyScope,
                    out IntPtr publicKeyPtr,
                    out uint publicKeyLength,
                    out uint hashAlgorithmId,
                    defaultCharArray,

                    // the default buffer size is taken from csproj call
                    GENMAN_STRING_BUF_SIZE,
                    out uint nameLength,
                    asmMetaPtr,
                    out uint flags);

                assemblyAttributes.AssemblyName = new string(defaultCharArray, 0, (int)nameLength - 1);
                assemblyAttributes.DefaultAlias = assemblyAttributes.AssemblyName;

                asmMeta = (ASSEMBLYMETADATA)Marshal.PtrToStructure(asmMetaPtr, typeof(ASSEMBLYMETADATA));
                assemblyAttributes.MajorVersion = asmMeta.usMajorVersion;
                assemblyAttributes.MinorVersion = asmMeta.usMinorVersion;
                assemblyAttributes.RevisionNumber = asmMeta.usRevisionNumber;
                assemblyAttributes.BuildNumber = asmMeta.usBuildNumber;
                assemblyAttributes.Culture = Marshal.PtrToStringUni(asmMeta.rpLocale);

                byte[] publicKey = new byte[publicKeyLength];
                Marshal.Copy(publicKeyPtr, publicKey, 0, (int)publicKeyLength);
                assemblyAttributes.PublicHexKey = BitConverter.ToString(publicKey).Replace("-", string.Empty);

                if (import2 != null)
                {
                    assemblyAttributes.Description = GetStringCustomAttribute(import2, assemblyScope, "System.Reflection.AssemblyDescriptionAttribute");
                    assemblyAttributes.TargetFrameworkMoniker = GetStringCustomAttribute(import2, assemblyScope, "System.Runtime.Versioning.TargetFrameworkAttribute");
                    var guid = GetStringCustomAttribute(import2, assemblyScope, "System.Runtime.InteropServices.GuidAttribute");
                    if (!string.IsNullOrEmpty(guid))
                    {
                        string importedFromTypeLibString = GetStringCustomAttribute(import2, assemblyScope, "System.Runtime.InteropServices.ImportedFromTypeLibAttribute");
                        if (!string.IsNullOrEmpty(importedFromTypeLibString))
                        {
                            assemblyAttributes.IsImportedFromTypeLib = true;
                        }
                        else
                        {
                            string primaryInteropAssemblyString = GetStringCustomAttribute(import2, assemblyScope, "System.Runtime.InteropServices.PrimaryInteropAssemblyAttribute");
                            assemblyAttributes.IsImportedFromTypeLib = !string.IsNullOrEmpty(primaryInteropAssemblyString);
                        }
                    }
                }

                assemblyAttributes.RuntimeVersion = GetRuntimeVersion(_sourceFile);

                import2.GetPEKind(out uint peKind, out _);
                assemblyAttributes.PeKind = peKind;

                return assemblyAttributes;
            }
            finally
            {
                FreeAsmMeta(asmMetaPtr, ref asmMeta);
            }
        }

        private string GetStringCustomAttribute(IMetaDataImport2 import2, uint assemblyScope, string attributeName)
        {
            int hr = import2.GetCustomAttributeByName(assemblyScope, attributeName, out IntPtr data, out uint valueLen);

            if (hr == NativeMethodsShared.S_OK)
            {
                // if an custom attribute exists, parse the contents of the blob
                if (NativeMethods.TryReadMetadataString(_sourceFile, data, valueLen, out string propertyValue))
                {
                    return propertyValue;
                }
            }

            return string.Empty;
        }
#endif

        /// <summary>
        /// Get the framework name from the assembly.
        /// </summary>
        private FrameworkName GetFrameworkName()
        {
#if !FEATURE_ASSEMBLYLOADCONTEXT
            if (!NativeMethodsShared.IsWindows)
            {
                CustomAttributeData attr = null;

                foreach (CustomAttributeData a in _assembly.GetCustomAttributesData())
                {
                    try
                    {
                        if (a.AttributeType == typeof(TargetFrameworkAttribute))
                        {
                            attr = a;
                            break;
                        }
                    }
                    catch
                    {
                    }
                }

                string name = null;
                if (attr != null)
                {
                    name = (string)attr.ConstructorArguments[0].Value;
                }
                return name == null ? null : new FrameworkName(name);
            }

            FrameworkName frameworkAttribute = null;
            try
            {
                var import2 = (IMetaDataImport2)_assemblyImport;
                _assemblyImport.GetAssemblyFromScope(out uint assemblyScope);

                string frameworkNameAttribute = GetStringCustomAttribute(import2, assemblyScope, s_targetFrameworkAttribute);
                if (!string.IsNullOrEmpty(frameworkNameAttribute))
                {
                    frameworkAttribute = new FrameworkName(frameworkNameAttribute);
                }
            }
            catch (Exception e) when (!ExceptionHandling.IsCriticalException(e))
            {
            }

            return frameworkAttribute;
#else
            CorePopulateMetadata();
            return _frameworkName;
#endif
        }

#if FEATURE_ASSEMBLYLOADCONTEXT
        /// <summary>
        /// Read everything from the assembly in a single stream.
        /// </summary>
        /// <returns></returns>
        private void CorePopulateMetadata()
        {
            if (_metadataRead)
            {
                return;
            }

            lock (this)
            {
                if (_metadataRead)
                {
                    return;
                }

                using (var stream = File.OpenRead(_sourceFile))
                using (var peFile = new PEReader(stream))
                {
                    bool hasMetadata = false;
                    try
                    {
                        // This can throw if the stream is too small, which means
                        // the assembly doesn't have metadata.
                        hasMetadata = peFile.HasMetadata;
                    }
                    finally
                    {
                        // If the file does not contain PE metadata, throw BadImageFormatException to preserve
                        // behavior from AssemblyName.GetAssemblyName(). RAR will deal with this correctly.
                        if (!hasMetadata)
                        {
                            throw new BadImageFormatException(string.Format(CultureInfo.CurrentCulture,
                                AssemblyResources.GetString("ResolveAssemblyReference.AssemblyDoesNotContainPEMetadata"),
                                _sourceFile));
                        }
                    }

                    var metadataReader = peFile.GetMetadataReader();

                    var assemblyReferences = metadataReader.AssemblyReferences;

                    List<AssemblyNameExtension> ret = new List<AssemblyNameExtension>(assemblyReferences.Count);

                    foreach (var handle in assemblyReferences)
                    {
                        var assemblyName = GetAssemblyName(metadataReader, handle);
                        ret.Add(new AssemblyNameExtension(assemblyName));
                    }

                    _assemblyDependencies = ret.ToArray();

                    foreach (var attrHandle in metadataReader.GetAssemblyDefinition().GetCustomAttributes())
                    {
                        var attr = metadataReader.GetCustomAttribute(attrHandle);

                        var ctorHandle = attr.Constructor;
                        if (ctorHandle.Kind != HandleKind.MemberReference)
                        {
                            continue;
                        }

                        var container = metadataReader.GetMemberReference((MemberReferenceHandle)ctorHandle).Parent;
                        if (container.Kind != HandleKind.TypeReference)
                        {
                            continue;
                        }

                        var name = metadataReader.GetTypeReference((TypeReferenceHandle)container).Name;
                        if (!string.Equals(metadataReader.GetString(name), "TargetFrameworkAttribute"))
                        {
                            continue;
                        }

                        var arguments = GetFixedStringArguments(metadataReader, attr);
                        if (arguments.Count == 1)
                        {
                            _frameworkName = new FrameworkName(arguments[0]);
                        }
                    }

                    var assemblyFilesCollection = metadataReader.AssemblyFiles;

                    List<string> assemblyFiles = new List<string>(assemblyFilesCollection.Count);

                    foreach (var fileHandle in assemblyFilesCollection)
                    {
                        assemblyFiles.Add(metadataReader.GetString(metadataReader.GetAssemblyFile(fileHandle).Name));
                    }

                    _assemblyFiles = assemblyFiles.ToArray();
                }

                _metadataRead = true;
            }
        }

        // https://github.com/dotnet/msbuild/issues/4002
        // https://github.com/dotnet/corefx/issues/34008
        //
        // We do not use AssemblyReference.GetAssemblyName() here because its behavior
        // is different from other code paths with respect to neutral culture. We will
        // get unspecified culture instead of explicitly neutral culture. This in turn
        // leads string comparisons of assembly-name-modulo-version in RAR to false
        // negatives that break its conflict resolution and binding redirect generation.
        private static AssemblyName GetAssemblyName(MetadataReader metadataReader, AssemblyReferenceHandle handle)
        {
            var entry = metadataReader.GetAssemblyReference(handle);

            var assemblyName = new AssemblyName
            {
                Name = metadataReader.GetString(entry.Name),
                Version = entry.Version,
                CultureName = metadataReader.GetString(entry.Culture)
            };

            var publicKeyOrToken = metadataReader.GetBlobBytes(entry.PublicKeyOrToken);
            if (publicKeyOrToken != null)
            {
                if (publicKeyOrToken.Length <= 8)
                {
                    assemblyName.SetPublicKeyToken(publicKeyOrToken);
                }
                else
                {
                    assemblyName.SetPublicKey(publicKeyOrToken);
                }
            }

            assemblyName.Flags = (AssemblyNameFlags)(int)entry.Flags;
            return assemblyName;
        }
#endif

#if FEATURE_ASSEMBLYLOADCONTEXT
        // This method copied from DNX source: https://github.com/aspnet/dnx/blob/e0726f769aead073af2d8cd9db47b89e1745d574/src/Microsoft.Dnx.Tooling/Utils/LockFileUtils.cs#L385
        //  System.Reflection.Metadata 1.1 is expected to have an API that helps with this.
        /// <summary>
        /// Gets the fixed (required) string arguments of a custom attribute.
        /// Only attributes that have only fixed string arguments.
        /// </summary>
        private static List<string> GetFixedStringArguments(MetadataReader reader, CustomAttribute attribute)
        {
            // TODO: Nick Guerrera (Nick.Guerrera@microsoft.com) hacked this method for temporary use.
            // There is a blob decoder feature in progress but it won't ship in time for our milestone.
            // Replace this method with the blob decoder feature when later it is availale.

            var signature = reader.GetMemberReference((MemberReferenceHandle)attribute.Constructor).Signature;
            var signatureReader = reader.GetBlobReader(signature);
            var valueReader = reader.GetBlobReader(attribute.Value);
            var arguments = new List<string>();

            var prolog = valueReader.ReadUInt16();
            if (prolog != 1)
            {
                // Invalid custom attribute prolog
                return arguments;
            }

            var header = signatureReader.ReadSignatureHeader();
            if (header.Kind != SignatureKind.Method || header.IsGeneric)
            {
                // Invalid custom attribute constructor signature
                return arguments;
            }

            int parameterCount;
            if (!signatureReader.TryReadCompressedInteger(out parameterCount))
            {
                // Invalid custom attribute constructor signature
                return arguments;
            }

            var returnType = signatureReader.ReadSignatureTypeCode();
            if (returnType != SignatureTypeCode.Void)
            {
                // Invalid custom attribute constructor signature
                return arguments;
            }

            for (int i = 0; i < parameterCount; i++)
            {
                var signatureTypeCode = signatureReader.ReadSignatureTypeCode();
                if (signatureTypeCode == SignatureTypeCode.String)
                {
                    // Custom attribute constructor must take only strings
                    arguments.Add(valueReader.ReadSerializedString());
                }
            }

            return arguments;
        }
#endif

#if !FEATURE_ASSEMBLYLOADCONTEXT
        /// <summary>
        /// Release interface pointers on Dispose().
        /// </summary>
        protected override void DisposeUnmanagedResources()
        {
            if (NativeMethodsShared.IsWindows)
            {
                if (_assemblyImport != null)
                {
                    Marshal.ReleaseComObject(_assemblyImport);
                }

                if (_metadataDispenser != null)
                {
                    Marshal.ReleaseComObject(_metadataDispenser);
                }
            }
        }
#endif

        /// <summary>
        /// Given a path get the CLR runtime version of the file
        /// </summary>
        /// <param name="path">path to the file</param>
        /// <returns>The CLR runtime version or empty if the path does not exist.</returns>
        internal static string GetRuntimeVersion(string path)
        {
#if FEATURE_MSCOREE
            if (NativeMethodsShared.IsWindows)
            {
#if DEBUG
                // Just to make sure and exercise the code that uses dwLength to allocate the buffer
                // when GetRequestedRuntimeInfo fails due to insufficient buffer size.
                int bufferLength = 1;
#else
                int bufferLength = 11; // 11 is the length of a runtime version and null terminator v2.0.50727/0
#endif

                unsafe
                {
                    // Allocate an initial buffer
                    char* runtimeVersion = stackalloc char[bufferLength];

                    // Run GetFileVersion, this should succeed using the initial buffer.
                    // It also returns the dwLength which is used if there is insufficient buffer.
                    uint hresult = NativeMethods.GetFileVersion(path, runtimeVersion, bufferLength, out int dwLength);

                    if (hresult == NativeMethodsShared.ERROR_INSUFFICIENT_BUFFER)
                    {
                        // Allocate new buffer based on the returned length.
                        char* runtimeVersion2 = stackalloc char[dwLength];
                        runtimeVersion = runtimeVersion2;

                        // Get the RuntimeVersion in this second call.
                        bufferLength = dwLength;
                        hresult = NativeMethods.GetFileVersion(path, runtimeVersion, bufferLength, out dwLength);
                    }

                    return hresult == NativeMethodsShared.S_OK ? new string(runtimeVersion, 0, dwLength - 1) : string.Empty;
                }
            }
            else
            {
                return ManagedRuntimeVersionReader.GetRuntimeVersion(path);
            }
#else
            return ManagedRuntimeVersionReader.GetRuntimeVersion(path);
#endif
        }

        /// <summary>
        /// Import assembly dependencies.
        /// </summary>
        /// <returns>The array of assembly dependencies.</returns>
        private AssemblyNameExtension[] ImportAssemblyDependencies()
        {
#if !FEATURE_ASSEMBLYLOADCONTEXT
            var asmRefs = new List<AssemblyNameExtension>();

            if (!NativeMethodsShared.IsWindows)
            {
                return _assembly.GetReferencedAssemblies().Select(a => new AssemblyNameExtension(a)).ToArray();
            }

            IntPtr asmRefEnum = IntPtr.Zero;
            var asmRefTokens = new UInt32[GENMAN_ENUM_TOKEN_BUF_SIZE];
            // Ensure the enum handle is closed.
            try
            {
                // Enum chunks of refs in 16-ref blocks until we run out.
                UInt32 fetched;
                do
                {
                    _assemblyImport.EnumAssemblyRefs(
                        ref asmRefEnum,
                        asmRefTokens,
                        (uint)asmRefTokens.Length,
                        out fetched);

                    for (uint i = 0; i < fetched; i++)
                    {
                        // Determine the length of the string to contain the name first.
                        _assemblyImport.GetAssemblyRefProps(
                            asmRefTokens[i],
                            out IntPtr pubKeyPtr,
                            out uint pubKeyBytes,
                            null,
                            0,
                            out uint asmNameLength,
                            IntPtr.Zero,
                            out _,
                            out _,
                            out uint flags);
                        // Allocate assembly name buffer.
                        var asmNameBuf = new char[asmNameLength + 1];
                        IntPtr asmMetaPtr = IntPtr.Zero;
                        // Ensure metadata structure is freed.
                        try
                        {
                            // Allocate metadata structure.
                            asmMetaPtr = AllocAsmMeta();
                            // Retrieve the assembly reference properties.
                            _assemblyImport.GetAssemblyRefProps(
                                asmRefTokens[i],
                                out pubKeyPtr,
                                out pubKeyBytes,
                                asmNameBuf,
                                (uint)asmNameBuf.Length,
                                out asmNameLength,
                                asmMetaPtr,
                                out _,
                                out _,
                                out flags);
                            // Construct the assembly name and free metadata structure.
                            AssemblyNameExtension asmName = ConstructAssemblyName(
                                asmMetaPtr,
                                asmNameBuf,
                                asmNameLength,
                                pubKeyPtr,
                                pubKeyBytes,
                                flags);
                            // Add the assembly name to the reference list.
                            asmRefs.Add(asmName);
                        }
                        finally
                        {
                            FreeAsmMeta(asmMetaPtr);
                        }
                    }
                } while (fetched > 0);
            }
            finally
            {
                if (asmRefEnum != IntPtr.Zero)
                {
                    _assemblyImport.CloseEnum(asmRefEnum);
                }
            }

            return asmRefs.ToArray();
#else
            CorePopulateMetadata();
            return _assemblyDependencies;
#endif
        }


        /// <summary>
        /// Import extra files. These are usually consituent members of a scatter assembly.
        /// </summary>
        /// <returns>The extra files of assembly dependencies.</returns>
        private string[] ImportFiles()
        {
#if !FEATURE_ASSEMBLYLOADCONTEXT
            var files = new List<string>();
            IntPtr fileEnum = IntPtr.Zero;
            var fileTokens = new UInt32[GENMAN_ENUM_TOKEN_BUF_SIZE];
            var fileNameBuf = new char[GENMAN_STRING_BUF_SIZE];

            // Ensure the enum handle is closed.
            try
            {
                // Enum chunks of files until we run out.
                UInt32 fetched;
                do
                {
                    _assemblyImport.EnumFiles(ref fileEnum, fileTokens, (uint)fileTokens.Length, out fetched);

                    for (uint i = 0; i < fetched; i++)
                    {
                        // Retrieve file properties.
                        _assemblyImport.GetFileProps(fileTokens[i],
                            fileNameBuf, (uint)fileNameBuf.Length, out uint fileNameLength,
                            out _, out _, out _);

                        // Add file to file list.
                        string file = new string(fileNameBuf, 0, (int)(fileNameLength - 1));
                        files.Add(file);
                    }
                } while (fetched > 0);
            }
            finally
            {
                if (fileEnum != IntPtr.Zero)
                {
                    _assemblyImport.CloseEnum(fileEnum);
                }
            }

            return files.ToArray();
#else
            CorePopulateMetadata();
            return _assemblyFiles;
#endif
        }

#if !FEATURE_ASSEMBLYLOADCONTEXT
        /// <summary>
        /// Allocate assembly metadata structure buffer.
        /// </summary>
        /// <returns>Pointer to structure</returns>
        private static IntPtr AllocAsmMeta()
        {
            ASSEMBLYMETADATA asmMeta;
            asmMeta.usMajorVersion = asmMeta.usMinorVersion = asmMeta.usBuildNumber = asmMeta.usRevisionNumber = 0;
            asmMeta.cOses = asmMeta.cProcessors = 0;
            asmMeta.rOses = asmMeta.rpProcessors = IntPtr.Zero;
            // Allocate buffer for locale.
            asmMeta.rpLocale = Marshal.AllocCoTaskMem(GENMAN_LOCALE_BUF_SIZE * 2);
            asmMeta.cchLocale = GENMAN_LOCALE_BUF_SIZE;
            // Convert to unmanaged structure.
            int size = Marshal.SizeOf<ASSEMBLYMETADATA>();
            IntPtr asmMetaPtr = Marshal.AllocCoTaskMem(size);
            Marshal.StructureToPtr(asmMeta, asmMetaPtr, false);

            return asmMetaPtr;
        }

        /// <summary>
        /// Construct assembly name.
        /// </summary>
        /// <param name="asmMetaPtr">Assembly metadata structure</param>
        /// <param name="asmNameBuf">Buffer containing the name</param>
        /// <param name="asmNameLength">Length of that buffer</param>
        /// <param name="pubKeyPtr">Pointer to public key</param>
        /// <param name="pubKeyBytes">Count of bytes in public key.</param>
        /// <param name="flags">Extra flags</param>
        /// <returns>The assembly name.</returns>
        private static AssemblyNameExtension ConstructAssemblyName(IntPtr asmMetaPtr, char[] asmNameBuf, UInt32 asmNameLength, IntPtr pubKeyPtr, UInt32 pubKeyBytes, UInt32 flags)
        {
            // Marshal the assembly metadata back to a managed type.
            ASSEMBLYMETADATA asmMeta = (ASSEMBLYMETADATA)Marshal.PtrToStructure(asmMetaPtr, typeof(ASSEMBLYMETADATA));

            // Construct the assembly name. (Note asmNameLength should/must be > 0.)
            var assemblyName = new AssemblyName
            {
                Name = new string(asmNameBuf, 0, (int)asmNameLength - 1),
                Version = new Version(
                    asmMeta.usMajorVersion,
                    asmMeta.usMinorVersion,
                    asmMeta.usBuildNumber,
                    asmMeta.usRevisionNumber)
            };

            // Set culture info.
            string locale = Marshal.PtrToStringUni(asmMeta.rpLocale);
            if (locale.Length > 0)
            {
                assemblyName.CultureInfo = CultureInfo.CreateSpecificCulture(locale);
            }
            else
            {
                assemblyName.CultureInfo = CultureInfo.CreateSpecificCulture(String.Empty);
            }

            // Set public key or PKT.
            var publicKey = new byte[pubKeyBytes];
            Marshal.Copy(pubKeyPtr, publicKey, 0, (int)pubKeyBytes);
            if ((flags & (uint)CorAssemblyFlags.afPublicKey) != 0)
            {
                assemblyName.SetPublicKey(publicKey);
            }
            else
            {
                assemblyName.SetPublicKeyToken(publicKey);
            }

            assemblyName.Flags = (AssemblyNameFlags)flags;
            return new AssemblyNameExtension(assemblyName);
        }

        /// <summary>
        /// Free the assembly metadata structure.
        /// </summary>
        /// <param name="asmMetaPtr">The pointer.</param>
        private static void FreeAsmMeta(IntPtr asmMetaPtr)
        {
            if (asmMetaPtr != IntPtr.Zero)
            {
                // Marshal the assembly metadata back to a managed type.
                var asmMeta = (ASSEMBLYMETADATA)Marshal.PtrToStructure(asmMetaPtr, typeof(ASSEMBLYMETADATA));
                FreeAsmMeta(asmMetaPtr, ref asmMeta);
            }
        }

        /// <summary>
        /// Free the assembly metadata structure.
        /// </summary>
        /// <param name="asmMetaPtr">The pointer.</param>
        /// <param name="asmMeta">Marshaled assembly metadata to the managed type.</param>
        private static void FreeAsmMeta(IntPtr asmMetaPtr, ref ASSEMBLYMETADATA asmMeta)
        {
            if (asmMetaPtr != IntPtr.Zero)
            {
                // Free unmanaged memory.
                Marshal.FreeCoTaskMem(asmMeta.rpLocale);
                asmMeta.rpLocale = IntPtr.Zero;
                Marshal.DestroyStructure(asmMetaPtr, typeof(ASSEMBLYMETADATA));
                Marshal.FreeCoTaskMem(asmMetaPtr);
            }
        }
#endif
    }

    /// <summary>
    /// Managed implementation of a reader for getting the runtime version of an assembly
    /// </summary>
    internal static class ManagedRuntimeVersionReader
    {
        private class HeaderInfo
        {
            public uint VirtualAddress;
            public uint Size;
            public uint FileOffset;
        }

        /// <summary>
        /// Given a path get the CLR runtime version of the file.
        /// </summary>
        /// <param name="path">path to the file</param>
        /// <returns>The CLR runtime version or empty if the path does not exist or the file is not an assembly.</returns>
        public static string GetRuntimeVersion(string path)
        {
            if (!FileSystems.Default.FileExists(path))
            {
                return string.Empty;
            }

            using Stream stream = File.OpenRead(path);
            using BinaryReader reader = new BinaryReader(stream);
            return GetRuntimeVersion(reader);
        }

        /// <summary>
        /// Given a <see cref="BinaryReader"/> get the CLR runtime version of the underlying file.
        /// </summary>
        /// <param name="sr">A <see cref="BinaryReader"/> positioned at the first byte of the file.</param>
        /// <returns>The CLR runtime version or empty if the data does not represent an assembly.</returns>
        internal static string GetRuntimeVersion(BinaryReader sr)
        {
            // This algorithm for getting the runtime version is based on
            // the ECMA Standard 335: The Common Language Infrastructure (CLI)
            // http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-335.pdf

            try
            {
                const uint PEHeaderPointerOffset = 0x3c;
                const uint PEHeaderSize = 20;
                const uint OptionalPEHeaderSize = 224;
                const uint OptionalPEPlusHeaderSize = 240;
                const uint SectionHeaderSize = 40;

                // The PE file format is specified in section II.25

                // A PE image starts with an MS-DOS header followed by a PE signature, followed by the PE file header,
                // and then the PE optional header followed by PE section headers.
                // There must be room for all of that.

                if (sr.BaseStream.Length < PEHeaderPointerOffset + 4 + PEHeaderSize + OptionalPEHeaderSize +
                    SectionHeaderSize)
                {
                    return string.Empty;
                }

                // The PE format starts with an MS-DOS stub of 128 bytes.
                // At offset 0x3c in the DOS header is a 4-byte unsigned integer offset to the PE
                // signature (shall be “PE\0\0”), immediately followed by the PE file header

                sr.BaseStream.Position = PEHeaderPointerOffset;
                var peHeaderOffset = sr.ReadUInt32();

                if (peHeaderOffset + 4 + PEHeaderSize + OptionalPEHeaderSize + SectionHeaderSize >=
                    sr.BaseStream.Length)
                {
                    return string.Empty;
                }

                // The PE header is specified in section II.25.2
                // Read the PE header signature

                sr.BaseStream.Position = peHeaderOffset;
                if (!ReadBytes(sr, (byte)'P', (byte)'E', 0, 0))
                {
                    return string.Empty;
                }

                // The PE header immediately follows the signature
                var peHeaderBase = peHeaderOffset + 4;

                // At offset 2 of the PE header there is the number of sections
                sr.BaseStream.Position = peHeaderBase + 2;
                var numberOfSections = sr.ReadUInt16();
                if (numberOfSections > 96)
                {
                    return string.Empty; // There can't be more than 96 sections, something is wrong
                }

                // Immediately after the PE Header is the PE Optional Header.
                // This header is optional in the general PE spec, but always
                // present in assembly files.
                // From this header we'll get the CLI header RVA, which is
                // at offset 208 for PE32, and at offset 224 for PE32+

                var optionalHeaderOffset = peHeaderBase + PEHeaderSize;

                uint cliHeaderRvaOffset;
                uint optionalPEHeaderSize;

                sr.BaseStream.Position = optionalHeaderOffset;
                var magicNumber = sr.ReadUInt16();

                if (magicNumber == 0x10b) // PE32
                {
                    optionalPEHeaderSize = OptionalPEHeaderSize;
                    cliHeaderRvaOffset = optionalHeaderOffset + 208;
                }
                else if (magicNumber == 0x20b) // PE32+
                {
                    optionalPEHeaderSize = OptionalPEPlusHeaderSize;
                    cliHeaderRvaOffset = optionalHeaderOffset + 224;
                }
                else
                {
                    return string.Empty;
                }

                // Read the CLI header RVA

                sr.BaseStream.Position = cliHeaderRvaOffset;
                var cliHeaderRva = sr.ReadUInt32();
                if (cliHeaderRva == 0)
                {
                    return string.Empty; // No CLI section
                }

                // Immediately following the optional header is the Section
                // Table, which contains a number of section headers.
                // Section headers are specified in section II.25.3

                // Each section header has the base RVA, size, and file
                // offset of the section. To find the file offset of the
                // CLI header we need to find a section that contains
                // its RVA, and the calculate the file offset using
                // the base file offset of the section.

                var sectionOffset = optionalHeaderOffset + optionalPEHeaderSize;

                // Read all section headers, we need them to make RVA to
                // offset conversions.

                var sections = new HeaderInfo[numberOfSections];
                for (int n = 0; n < numberOfSections; n++)
                {
                    // At offset 8 of the section is the section size
                    // and base RVA. At offset 20 there is the file offset
                    sr.BaseStream.Position = sectionOffset + 8;
                    var sectionSize = sr.ReadUInt32();
                    var sectionRva = sr.ReadUInt32();
                    sr.BaseStream.Position = sectionOffset + 20;
                    var sectionDataOffset = sr.ReadUInt32();
                    sections[n] = new HeaderInfo
                    {
                        VirtualAddress = sectionRva,
                        Size = sectionSize,
                        FileOffset = sectionDataOffset
                    };
                    sectionOffset += SectionHeaderSize;
                }

                uint cliHeaderOffset = RvaToOffset(sections, cliHeaderRva);

                // CLI section not found
                if (cliHeaderOffset == 0)
                {
                    return string.Empty;
                }

                // The CLI header is specified in section II.25.3.3.
                // It contains all of the runtime-specific data entries and other information.
                // From the CLI header we need to get the RVA of the metadata root,
                // which is located at offset 8.

                sr.BaseStream.Position = cliHeaderOffset + 8;
                var metadataRva = sr.ReadUInt32();

                var metadataOffset = RvaToOffset(sections, metadataRva);
                if (metadataOffset == 0)
                {
                    return string.Empty;
                }

                // The metadata root is specified in section II.24.2.1
                // The first 4 bytes contain a signature.
                // The version string is at offset 12.

                sr.BaseStream.Position = metadataOffset;
                if (!ReadBytes(sr, 0x42, 0x53, 0x4a, 0x42)) // Metadata root signature
                {
                    return string.Empty;
                }

                // Read the version string length
                sr.BaseStream.Position = metadataOffset + 12;
                var length = sr.ReadInt32();
                if (length > 255 || length <= 0 || sr.BaseStream.Position + length >= sr.BaseStream.Length)
                {
                    return string.Empty;
                }

                // Read the version string
                var v = Encoding.UTF8.GetString(sr.ReadBytes(length));

                // Per II.24.2.1, version string length is rounded up
                // to a multiple of 4. So we may read eg "4.0.30319\0\0"
                // Version.Parse works fine, but it's not pretty in the log.
                int firstNull = v.IndexOf('\0');
                if (firstNull > 0)
                {
                    v = v.Substring(0, firstNull);
                }

                return v;
            }
            catch
            {
                // Something went wrong in spite of all checks. Corrupt file?
                return string.Empty;
            }
        }

        private static bool ReadBytes(BinaryReader r, params byte[] bytes)
        {
            foreach (byte b in bytes)
            {
                if (b != r.ReadByte())
                {
                    return false;
                }
            }

            return true;
        }

        private static uint RvaToOffset(HeaderInfo[] sections, uint rva)
        {
            foreach (var s in sections)
            {
                if (rva >= s.VirtualAddress && rva < s.VirtualAddress + s.Size)
                {
                    return s.FileOffset + (rva - s.VirtualAddress);
                }
            }
            return 0;
        }
    }
}