예제 #1
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="module">The owner module</param>
 public CorLibTypes(ModuleDef module)
     : this(module, null)
 {
 }
예제 #2
0
 /// <summary>
 /// Finds and returns an <see cref="AssemblyDef"/>
 /// </summary>
 /// <param name="self">this</param>
 /// <param name="assembly">The assembly to find</param>
 /// <param name="sourceModule">The module that needs to resolve an assembly or <c>null</c></param>
 /// <returns>An <see cref="AssemblyDef"/> instance owned by the assembly resolver or
 /// <c>null</c> if the assembly couldn't be found.</returns>
 public static AssemblyDef Resolve(this IAssemblyResolver self, AssemblyName assembly, ModuleDef sourceModule)
 {
     if (assembly == null)
     {
         return(null);
     }
     return(self.Resolve(new AssemblyNameInfo(assembly), sourceModule));
 }
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="ownerModule">Module that will own the returned <see cref="IType"/> or <c>null</c></param>
 /// <param name="typeFullName">Full name of type</param>
 /// <param name="typeNameParserHelper">Helper class</param>
 public ReflectionTypeNameParser(ModuleDef ownerModule, string typeFullName, IAssemblyRefFinder typeNameParserHelper)
     : base(ownerModule, typeFullName, typeNameParserHelper)
 {
 }
예제 #4
0
 /// <summary>
 /// Finds and returns an <see cref="AssemblyDef"/>
 /// </summary>
 /// <param name="self">this</param>
 /// <param name="asmFullName">The assembly to find</param>
 /// <param name="sourceModule">The module that needs to resolve an assembly or <c>null</c></param>
 /// <returns>An <see cref="AssemblyDef"/> instance owned by the assembly resolver or
 /// <c>null</c> if the assembly couldn't be found.</returns>
 public static AssemblyDef Resolve(this IAssemblyResolver self, string asmFullName, ModuleDef sourceModule)
 {
     if (asmFullName == null)
     {
         return(null);
     }
     return(self.Resolve(new AssemblyNameInfo(asmFullName), sourceModule));
 }
예제 #5
0
 /// <summary>
 /// Add a module's assembly to the assembly cache
 /// </summary>
 /// <param name="self">this</param>
 /// <param name="module">The module whose assembly should be cached</param>
 /// <returns><c>true</c> if <paramref name="module"/>'s assembly is cached, <c>false</c>
 /// if it's not cached because some other assembly with the exact same full name has
 /// already been cached or if <paramref name="module"/> or its assembly is <c>null</c>.</returns>
 public static bool AddToCache(this IAssemblyResolver self, ModuleDef module)
 {
     return(module != null && self.AddToCache(module.Assembly));
 }
 /// <summary>
 /// Gets all module search paths. This is usually empty unless its assembly has
 /// a <c>.config</c> file specifying any additional private search paths in a
 /// &lt;probing/&gt; element.
 /// </summary>
 /// <param name="module">The module or <c>null</c> if unknown</param>
 /// <returns>A list of search paths</returns>
 protected virtual IEnumerable <string> GetModuleSearchPaths(ModuleDef module)
 {
     return(GetModulePrivateSearchPaths(module));
 }
예제 #7
0
 public static void LoadAll(ModuleDef module, ICancellationToken cancellationToken)
 {
     new ModuleLoader(module, cancellationToken).Load();
 }
예제 #8
0
        /// <inheritdoc/>
        public TypeDef Resolve(TypeRef typeRef, ModuleDef sourceModule)
        {
            if (typeRef == null)
            {
                return(null);
            }

            if (ProjectWinMDRefs)
            {
                typeRef = WinMDHelpers.ToCLR(typeRef.Module ?? sourceModule, typeRef) ?? typeRef;
            }

            var nonNestedTypeRef = TypeRef.GetNonNestedTypeRef(typeRef);

            if (nonNestedTypeRef == null)
            {
                return(null);
            }

            var nonNestedResolutionScope = nonNestedTypeRef.ResolutionScope;
            var nonNestedModule          = nonNestedTypeRef.Module;
            var asmRef = nonNestedResolutionScope as AssemblyRef;

            if (asmRef != null)
            {
                var asm = assemblyResolver.Resolve(asmRef, sourceModule ?? nonNestedModule);
                return(asm == null ? null : asm.Find(typeRef) ?? ResolveExportedType(asm.Modules, typeRef, sourceModule));
            }

            var moduleDef = nonNestedResolutionScope as ModuleDef;

            if (moduleDef != null)
            {
                return(moduleDef.Find(typeRef) ??
                       ResolveExportedType(new ModuleDef[] { moduleDef }, typeRef, sourceModule));
            }

            var moduleRef = nonNestedResolutionScope as ModuleRef;

            if (moduleRef != null)
            {
                if (nonNestedModule == null)
                {
                    return(null);
                }
                if (new SigComparer().Equals(moduleRef, nonNestedModule))
                {
                    return(nonNestedModule.Find(typeRef) ??
                           ResolveExportedType(new ModuleDef[] { nonNestedModule }, typeRef, sourceModule));
                }
                var nonNestedAssembly = nonNestedModule.Assembly;
                if (nonNestedAssembly == null)
                {
                    return(null);
                }
                var resolvedModule = nonNestedAssembly.FindModule(moduleRef.Name);
                return(resolvedModule == null ? null : resolvedModule.Find(typeRef) ??
                       ResolveExportedType(new ModuleDef[] { resolvedModule }, typeRef, sourceModule));
            }

            return(null);
        }
 /// <summary>
 /// Reads a custom attribute
 /// </summary>
 /// <param name="module">Owner module</param>
 /// <param name="stream">A stream positioned at the the first byte of the CA blob</param>
 /// <param name="ctor">Custom attribute constructor</param>
 /// <returns>A new <see cref="CustomAttribute"/> instance or <c>null</c> if one of the
 /// args is <c>null</c> or if we failed to parse the CA blob</returns>
 public static CustomAttribute Read(ModuleDef module, IBinaryReader stream, ICustomAttributeType ctor)
 {
     return(Read(module, stream, ctor, new GenericParamContext()));
 }
예제 #10
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="module">Owner module</param>
 /// <param name="name">Type name</param>
 public TypeRefUser(ModuleDef module, UTF8String name)
     : this(module, UTF8String.Empty, name)
 {
 }
예제 #11
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="module">Owner module</param>
 /// <param name="namespace">Type namespace</param>
 /// <param name="name">Type name</param>
 public TypeRefUser(ModuleDef module, UTF8String @namespace, UTF8String name)
     : this(module, @namespace, name, null)
 {
 }
예제 #12
0
        /// <summary>
        /// Finds and returns an <see cref="AssemblyDef"/>
        /// </summary>
        /// <param name="self">this</param>
        /// <param name="assembly">The assembly to find</param>
        /// <param name="sourceModule">The module that needs to resolve an assembly or <c>null</c></param>
        /// <returns>An <see cref="AssemblyDef"/> instance owned by the assembly resolver</returns>
        /// <exception cref="AssemblyResolveException">If the assembly couldn't be found.</exception>
        public static AssemblyDef ResolveThrow(this IAssemblyResolver self, AssemblyName assembly, ModuleDef sourceModule)
        {
            if (assembly is null)
            {
                return(null);
            }
            var asm = self.Resolve(new AssemblyNameInfo(assembly), sourceModule);

            if (asm is not null)
            {
                return(asm);
            }
            throw new AssemblyResolveException($"Could not resolve assembly: {assembly}");
        }
예제 #13
0
 /// <summary>
 /// Tries to redirect a .NET Framework assembly from an older version to the correct version
 /// loaded at runtime.
 /// </summary>
 /// <param name="assembly">Assembly reference</param>
 /// <param name="sourceModule">Module using the assembly reference</param>
 /// <param name="redirectedAssembly">Updated with the redirected assembly if successful</param>
 /// <returns></returns>
 public static bool TryApplyFrameworkRedirect(IAssembly assembly, ModuleDef sourceModule, out IAssembly redirectedAssembly) =>
 TryApplyFrameworkRedirectCore(assembly, sourceModule, out redirectedAssembly);
예제 #14
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="module">The owner module</param>
 /// <param name="corLibAssemblyRef">Corlib assembly reference or <c>null</c> if a default
 /// assembly reference should be created</param>
 public CorLibTypes(ModuleDef module, AssemblyRef corLibAssemblyRef)
 {
     this.module            = module;
     this.corLibAssemblyRef = corLibAssemblyRef ?? CreateCorLibAssemblyRef();
     Initialize();
 }
        IEnumerable <string> FindAssembliesGacExactly(GacInfo gacInfo, IAssembly assembly, ModuleDef sourceModule)
        {
            var pkt = PublicKeyBase.ToPublicKeyToken(assembly.PublicKeyOrToken);

            if (gacInfo != null && pkt != null)
            {
                string pktString  = pkt.ToString();
                string verString  = Utils.CreateVersionWithNoUndefinedValues(assembly.Version).ToString();
                var asmSimpleName = UTF8String.ToSystemStringOrEmpty(assembly.Name);
                foreach (var subDir in gacInfo.subDirs)
                {
                    var baseDir = Path.Combine(gacInfo.path, subDir);
                    baseDir = Path.Combine(baseDir, asmSimpleName);
                    baseDir = Path.Combine(baseDir, string.Format("{0}{1}__{2}", gacInfo.prefix, verString, pktString));
                    var pathName = Path.Combine(baseDir, asmSimpleName + ".dll");
                    if (File.Exists(pathName))
                    {
                        yield return(pathName);
                    }
                }
            }
        }
예제 #16
0
 /// <summary>
 /// Parses a Reflection type name and creates a <see cref="TypeSig"/>
 /// </summary>
 /// <param name="ownerModule">Module that will own the returned <see cref="TypeSig"/> or <c>null</c></param>
 /// <param name="typeFullName">Full name of type</param>
 /// <param name="typeNameParserHelper">Helper class</param>
 /// <returns>A new <see cref="TypeSig"/> instance</returns>
 /// <exception cref="TypeNameParserException">If parsing failed</exception>
 public static TypeSig ParseAsTypeSigReflectionThrow(ModuleDef ownerModule, string typeFullName, IAssemblyRefFinder typeNameParserHelper)
 {
     return(ParseAsTypeSigReflectionThrow(ownerModule, typeFullName, typeNameParserHelper, new GenericParamContext()));
 }
 IEnumerable <string> FindAssembliesGacAny(GacInfo gacInfo, IAssembly assembly, ModuleDef sourceModule)
 {
     if (gacInfo != null)
     {
         var asmSimpleName = UTF8String.ToSystemStringOrEmpty(assembly.Name);
         foreach (var subDir in gacInfo.subDirs)
         {
             var baseDir = Path.Combine(gacInfo.path, subDir);
             baseDir = Path.Combine(baseDir, asmSimpleName);
             foreach (var dir in GetDirs(baseDir))
             {
                 var pathName = Path.Combine(dir, asmSimpleName + ".dll");
                 if (File.Exists(pathName))
                 {
                     yield return(pathName);
                 }
             }
         }
     }
 }
예제 #18
0
 /// <summary>
 /// Parses a Reflection type name and creates a <see cref="TypeSig"/>
 /// </summary>
 /// <param name="ownerModule">Module that will own the returned <see cref="TypeSig"/> or <c>null</c></param>
 /// <param name="typeFullName">Full name of type</param>
 /// <param name="typeNameParserHelper">Helper class</param>
 /// <param name="gpContext">Generic parameter context</param>
 /// <returns>A new <see cref="TypeSig"/> instance</returns>
 /// <exception cref="TypeNameParserException">If parsing failed</exception>
 public static TypeSig ParseAsTypeSigReflectionThrow(ModuleDef ownerModule, string typeFullName, IAssemblyRefFinder typeNameParserHelper, GenericParamContext gpContext)
 {
     using (var parser = new ReflectionTypeNameParser(ownerModule, typeFullName, typeNameParserHelper, gpContext))
         return(parser.ParseAsTypeSig());
 }
        /// <summary>
        /// Gets all private assembly search paths as found in the module's <c>.config</c> file.
        /// </summary>
        /// <param name="module">The module or <c>null</c> if unknown</param>
        /// <returns>A list of search paths</returns>
        protected IEnumerable <string> GetModulePrivateSearchPaths(ModuleDef module)
        {
            if (module == null)
            {
                return(new string[0]);
            }
            var asm = module.Assembly;

            if (asm == null)
            {
                return(new string[0]);
            }
            module = asm.ManifestModule;
            if (module == null)
            {
                return(new string[0]);                  // Should never happen
            }
            string baseDir = null;

            try
            {
                var imageName = module.Location;
                if (imageName != string.Empty)
                {
                    baseDir = Directory.GetParent(imageName).FullName;
                    var configName = imageName + ".config";
                    if (File.Exists(configName))
                    {
                        return(GetPrivatePaths(baseDir, configName));
                    }
                }
            }
            catch
            {
            }
            if (baseDir != null)
            {
                return new List <string> {
                           baseDir
                }
            }
            ;
            return(new string[0]);
        }

        IEnumerable <string> GetPrivatePaths(string baseDir, string configFileName)
        {
            var searchPaths = new List <string>();

            try
            {
                var dirName = Path.GetDirectoryName(Path.GetFullPath(configFileName));

                searchPaths.Add(dirName);

                using (var xmlStream = new FileStream(configFileName, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    var doc = new XmlDocument();
                    doc.Load(XmlReader.Create(xmlStream));
                    foreach (var tmp in doc.GetElementsByTagName("probing"))
                    {
                        var probingElem = tmp as XmlElement;
                        if (probingElem == null)
                        {
                            continue;
                        }
                        var privatePath = probingElem.GetAttribute("privatePath");
                        if (string.IsNullOrEmpty(privatePath))
                        {
                            continue;
                        }
                        foreach (var tmp2 in privatePath.Split(';'))
                        {
                            var path = tmp2.Trim();
                            if (path == "")
                            {
                                continue;
                            }
                            var newPath = Path.GetFullPath(Path.Combine(dirName, path.Replace('\\', Path.DirectorySeparatorChar)));
                            if (Directory.Exists(newPath) && newPath.StartsWith(baseDir + Path.DirectorySeparatorChar))
                            {
                                searchPaths.Add(newPath);
                            }
                        }
                    }
                }
            }
            catch (ArgumentException)
            {
            }
            catch (IOException)
            {
            }
            catch (XmlException)
            {
            }

            return(searchPaths);
        }
예제 #20
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="ownerModule">Module that will own the returned <see cref="IType"/> or <c>null</c></param>
 /// <param name="typeFullName">Full name of type</param>
 /// <param name="typeNameParserHelper">Helper class</param>
 protected TypeNameParser(ModuleDef ownerModule, string typeFullName, IAssemblyRefFinder typeNameParserHelper)
     : this(ownerModule, typeFullName, typeNameParserHelper, new GenericParamContext())
 {
 }
예제 #21
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="module">The module to search first</param>
 public CAAssemblyRefFinder(ModuleDef module)
 {
     this.module = module;
 }
예제 #22
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="ownerModule">Module that will own the returned <see cref="IType"/> or <c>null</c></param>
 /// <param name="typeFullName">Full name of type</param>
 /// <param name="typeNameParserHelper">Helper class</param>
 /// <param name="gpContext">Generic parameter context</param>
 public ReflectionTypeNameParser(ModuleDef ownerModule, string typeFullName, IAssemblyRefFinder typeNameParserHelper, GenericParamContext gpContext)
     : base(ownerModule, typeFullName, typeNameParserHelper, gpContext)
 {
 }
예제 #23
0
        /// <summary>
        /// Finds and returns an <see cref="AssemblyDef"/>
        /// </summary>
        /// <param name="self">this</param>
        /// <param name="asmFullName">The assembly to find</param>
        /// <param name="sourceModule">The module that needs to resolve an assembly or <c>null</c></param>
        /// <returns>An <see cref="AssemblyDef"/> instance owned by the assembly resolver</returns>
        /// <exception cref="AssemblyResolveException">If the assembly couldn't be found.</exception>
        public static AssemblyDef ResolveThrow(this IAssemblyResolver self, string asmFullName, ModuleDef sourceModule)
        {
            if (asmFullName == null)
            {
                return(null);
            }
            var asm = self.Resolve(new AssemblyNameInfo(asmFullName), sourceModule);

            if (asm != null)
            {
                return(asm);
            }
            throw new AssemblyResolveException(string.Format("Could not resolve assembly: {0}", asmFullName));
        }
예제 #24
0
 /// <summary>
 /// Parses a Reflection type name and creates a <see cref="ITypeDefOrRef"/>
 /// </summary>
 /// <param name="ownerModule">Module that will own the returned <see cref="ITypeDefOrRef"/> or <c>null</c></param>
 /// <param name="typeFullName">Full name of type</param>
 /// <param name="typeNameParserHelper">Helper class</param>
 /// <returns>A new <see cref="ITypeDefOrRef"/> instance or <c>null</c> if parsing failed</returns>
 public static ITypeDefOrRef ParseReflection(ModuleDef ownerModule, string typeFullName, IAssemblyRefFinder typeNameParserHelper)
 {
     return(ParseReflection(ownerModule, typeFullName, typeNameParserHelper, new GenericParamContext()));
 }
예제 #25
0
 /// <summary>
 /// Removes a module's assembly from the cache
 /// </summary>
 /// <param name="self">this</param>
 /// <param name="module">The module</param>
 /// <returns><c>true</c> if its assembly was removed, <c>false</c> if it wasn't removed
 /// since it wasn't in the cache, it has no assembly, or <paramref name="module"/> was
 /// <c>null</c></returns>
 public static bool Remove(this IAssemblyResolver self, ModuleDef module)
 {
     return(module != null && self.Remove(module.Assembly));
 }
        /// <inheritdoc/>
        public AssemblyDef Resolve(IAssembly assembly, ModuleDef sourceModule)
        {
            if (assembly == null)
            {
                return(null);
            }

            if (EnableFrameworkRedirect && !FindExactMatch)
            {
                FrameworkRedirect.ApplyFrameworkRedirect(ref assembly, sourceModule);
            }

#if THREAD_SAFE
            theLock.EnterWriteLock(); try {
#endif
            AssemblyDef resolvedAssembly = Resolve2(assembly, sourceModule);
            if (resolvedAssembly == null)
            {
                string asmName        = UTF8String.ToSystemStringOrEmpty(assembly.Name);
                string asmNameTrimmed = asmName.Trim();
                if (asmName != asmNameTrimmed)
                {
                    assembly = new AssemblyNameInfo
                    {
                        Name             = asmNameTrimmed,
                        Version          = assembly.Version,
                        PublicKeyOrToken = assembly.PublicKeyOrToken,
                        Culture          = assembly.Culture,
                    };
                    resolvedAssembly = Resolve2(assembly, sourceModule);
                }
            }

            if (resolvedAssembly == null)
            {
                // Make sure we don't search for this assembly again. This speeds up callers who
                // keep asking for this assembly when trying to resolve many different TypeRefs
                cachedAssemblies[GetAssemblyNameKey(assembly)] = null;
                return(null);
            }

            var key1 = GetAssemblyNameKey(resolvedAssembly);
            var key2 = GetAssemblyNameKey(assembly);
            AssemblyDef asm1, asm2;
            cachedAssemblies.TryGetValue(key1, out asm1);
            cachedAssemblies.TryGetValue(key2, out asm2);

            if (asm1 != resolvedAssembly && asm2 != resolvedAssembly)
            {
                // This assembly was just resolved
                if (enableTypeDefCache)
                {
                    foreach (var module in resolvedAssembly.Modules.GetSafeEnumerable())
                    {
                        if (module != null)
                        {
                            module.EnableTypeDefFindCache = true;
                        }
                    }
                }
            }

            bool inserted = false;
            if (!cachedAssemblies.ContainsKey(key1))
            {
                cachedAssemblies.Add(key1, resolvedAssembly);
                inserted = true;
            }
            if (!cachedAssemblies.ContainsKey(key2))
            {
                cachedAssemblies.Add(key2, resolvedAssembly);
                inserted = true;
            }
            if (inserted || asm1 == resolvedAssembly || asm2 == resolvedAssembly)
            {
                return(resolvedAssembly);
            }

            // Dupe assembly. Don't insert it.
            var dupeModule = resolvedAssembly.ManifestModule;
            if (dupeModule != null)
            {
                dupeModule.Dispose();
            }
            return(asm1 ?? asm2);

#if THREAD_SAFE
        }

        finally { theLock.ExitWriteLock(); }
#endif
        }
예제 #27
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="ownerModule">Module that will own the returned <see cref="IType"/> or <c>null</c></param>
 /// <param name="typeFullName">Full name of type</param>
 /// <param name="typeNameParserHelper">Helper class</param>
 protected TypeNameParser(ModuleDef ownerModule, string typeFullName, IAssemblyRefFinder typeNameParserHelper)
 {
     this.ownerModule          = ownerModule;
     this.reader               = new StringReader(typeFullName ?? string.Empty);
     this.typeNameParserHelper = typeNameParserHelper;
 }
 /// <summary>
 /// Called after <see cref="FindAssemblies"/> (if it fails)
 /// </summary>
 /// <param name="assembly">Assembly to find</param>
 /// <param name="sourceModule">The module that needs to resolve an assembly or <c>null</c></param>
 /// <param name="matchExactly">We're trying to find an exact match</param>
 /// <returns><c>null</c> or an enumerable of full paths to try</returns>
 protected virtual IEnumerable <string> PostFindAssemblies(IAssembly assembly, ModuleDef sourceModule, bool matchExactly)
 {
     foreach (var path in FindAssemblies2(assembly, postSearchPaths))
     {
         yield return(path);
     }
 }
예제 #29
0
 /// <summary>
 /// Parses a Reflection type name and creates a <see cref="ITypeDefOrRef"/>
 /// </summary>
 /// <param name="ownerModule">Module that will own the returned <see cref="ITypeDefOrRef"/> or <c>null</c></param>
 /// <param name="typeFullName">Full name of type</param>
 /// <param name="typeNameParserHelper">Helper class</param>
 /// <returns>A new <see cref="ITypeDefOrRef"/> instance</returns>
 /// <exception cref="TypeNameParserException">If parsing failed</exception>
 public static ITypeDefOrRef ParseReflectionThrow(ModuleDef ownerModule, string typeFullName, IAssemblyRefFinder typeNameParserHelper)
 {
     using (var parser = new ReflectionTypeNameParser(ownerModule, typeFullName, typeNameParserHelper))
         return(parser.Parse());
 }
 /// <summary>
 ///     Reads a custom attribute
 /// </summary>
 /// <param name="module">Owner module</param>
 /// <param name="caBlob">CA blob</param>
 /// <param name="ctor">Custom attribute constructor</param>
 /// <param name="gpContext">Generic parameter context</param>
 /// <returns>A new <see cref="CustomAttribute" /> instance</returns>
 public static CustomAttribute Read(ModuleDef module, byte[] caBlob, ICustomAttributeType ctor, GenericParamContext gpContext)
 {
     return(Read(module, MemoryImageStream.Create(caBlob), ctor, gpContext));
 }