The Labs \ Source Viewer \ SSCLI \ System.Configuration \ TypeUtil

  1. //------------------------------------------------------------------------------
  2. // <copyright file="TypeUtil.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. using System;
  16. using System.Configuration.Internal;
  17. using System.Reflection;
  18. using System.Security;
  19. using System.Security.Permissions;
  20. namespace System.Configuration
  21. {
  22.    
  23.     static internal class TypeUtil
  24.     {
  25.        
  26.         private static Type GetLegacyType(string typeString)
  27.         {
  28.             Type type = null;
  29.            
  30.             //
  31.             // Ignore all exceptions, otherwise callers will get unexpected
  32.             // exceptions not related to the original failure to load the
  33.             // desired type.
  34.             //
  35.             try {
  36.                 Assembly systemAssembly = typeof(ConfigurationException).Assembly;
  37.                 type = systemAssembly.GetType(typeString, false);
  38.             }
  39.             catch {
  40.             }
  41.            
  42.             return type;
  43.         }
  44.        
  45.         //
  46.         // Get the type specified by typeString. If it fails, try to retrieve it
  47.         // as a type from System.dll. If that fails, return null or throw the original
  48.         // exception as indicated by throwOnError.
  49.         //
  50.         private static Type GetTypeImpl(string typeString, bool throwOnError)
  51.         {
  52.             Type type = null;
  53.             Exception originalException = null;
  54.            
  55.             try {
  56.                 type = Type.GetType(typeString, throwOnError);
  57.             }
  58.             catch (Exception e) {
  59.                 originalException = e;
  60.             }
  61.            
  62.             if (type == null) {
  63.                 type = GetLegacyType(typeString);
  64.                 if (type == null && originalException != null) {
  65.                     throw originalException;
  66.                 }
  67.             }
  68.            
  69.             return type;
  70.         }
  71.        
  72.         //
  73.         // Ask the host to get the type specified by typeString. If it fails, try to retrieve it
  74.         // as a type from System.dll. If that fails, return null or throw the original
  75.         // exception as indicated by throwOnError.
  76.         //
  77.         [ReflectionPermission(SecurityAction.Assert, Flags = ReflectionPermissionFlag.TypeInformation)]
  78.         static internal Type GetTypeWithReflectionPermission(IInternalConfigHost host, string typeString, bool throwOnError)
  79.         {
  80.             Type type = null;
  81.             Exception originalException = null;
  82.            
  83.             try {
  84.                 type = host.GetConfigType(typeString, throwOnError);
  85.             }
  86.             catch (Exception e) {
  87.                 originalException = e;
  88.             }
  89.            
  90.             if (type == null) {
  91.                 type = GetLegacyType(typeString);
  92.                 if (type == null && originalException != null) {
  93.                     throw originalException;
  94.                 }
  95.             }
  96.            
  97.             return type;
  98.         }
  99.        
  100.         [ReflectionPermission(SecurityAction.Assert, Flags = ReflectionPermissionFlag.TypeInformation)]
  101.         static internal Type GetTypeWithReflectionPermission(string typeString, bool throwOnError)
  102.         {
  103.             return GetTypeImpl(typeString, throwOnError);
  104.         }
  105.        
  106.         [ReflectionPermission(SecurityAction.Assert, Flags = ReflectionPermissionFlag.TypeInformation | ReflectionPermissionFlag.MemberAccess)]
  107.         static internal object CreateInstanceWithReflectionPermission(string typeString)
  108.         {
  109.             Type type = GetTypeImpl(typeString, true);
  110.             // catch the errors and report them
  111.             object result = Activator.CreateInstance(type, true);
  112.             // create non-public types
  113.             return result;
  114.         }
  115.        
  116.         [ReflectionPermission(SecurityAction.Assert, Flags = ReflectionPermissionFlag.TypeInformation | ReflectionPermissionFlag.MemberAccess)]
  117.         static internal object CreateInstanceWithReflectionPermission(Type type)
  118.         {
  119.             object result = Activator.CreateInstance(type, true);
  120.             // create non-public types
  121.             return result;
  122.         }
  123.        
  124.         [ReflectionPermission(SecurityAction.Assert, Flags = ReflectionPermissionFlag.TypeInformation)]
  125.         static internal ConstructorInfo GetConstructorWithReflectionPermission(Type type, Type baseType, bool throwOnError)
  126.         {
  127.             type = VerifyAssignableType(baseType, type, throwOnError);
  128.             if (type == null) {
  129.                 return null;
  130.             }
  131.            
  132.             BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
  133.            
  134.             ConstructorInfo ctor = type.GetConstructor(bindingFlags, null, CallingConventions.HasThis, Type.EmptyTypes, null);
  135.             if (ctor == null && throwOnError) {
  136.                 throw new TypeLoadException(SR.GetString(SR.TypeNotPublic, type.AssemblyQualifiedName));
  137.             }
  138.            
  139.             return ctor;
  140.         }
  141.        
  142.         [ReflectionPermission(SecurityAction.Assert, Flags = ReflectionPermissionFlag.TypeInformation | ReflectionPermissionFlag.MemberAccess)]
  143.         static internal object InvokeCtorWithReflectionPermission(ConstructorInfo ctor)
  144.         {
  145.             return ctor.Invoke(null);
  146.         }
  147.        
  148.         static internal bool IsTypeFromTrustedAssemblyWithoutAptca(Type type)
  149.         {
  150.             Assembly assembly = type.Assembly;
  151.             return assembly.GlobalAssemblyCache && !HasAptcaBit(assembly);
  152.         }
  153.        
  154.         static internal Type VerifyAssignableType(Type baseType, Type type, bool throwOnError)
  155.         {
  156.             if (baseType.IsAssignableFrom(type)) {
  157.                 return type;
  158.             }
  159.            
  160.             if (throwOnError) {
  161.                 throw new TypeLoadException(SR.GetString(SR.Config_type_doesnt_inherit_from_type, type.FullName, baseType.FullName));
  162.             }
  163.            
  164.             return null;
  165.         }
  166.        
  167.         [ReflectionPermission(SecurityAction.Assert, Flags = ReflectionPermissionFlag.TypeInformation | ReflectionPermissionFlag.MemberAccess)]
  168.         private static bool HasAptcaBit(Assembly assembly)
  169.         {
  170.                 /*inherit*/            object[] attrs = assembly.GetCustomAttributes(typeof(System.Security.AllowPartiallyTrustedCallersAttribute), false);
  171.            
  172.             return (attrs != null && attrs.Length > 0);
  173.         }
  174.        
  175.         private static PermissionSet s_fullTrustPermissionSet;
  176.        
  177.         // Check if the caller is fully trusted
  178.         static internal bool IsCallerFullTrust {
  179.             get {
  180.                 bool isFullTrust = false;
  181.                 try {
  182.                     if (s_fullTrustPermissionSet == null) {
  183.                         s_fullTrustPermissionSet = new PermissionSet(PermissionState.Unrestricted);
  184.                     }
  185.                    
  186.                     s_fullTrustPermissionSet.Demand();
  187.                     isFullTrust = true;
  188.                 }
  189.                 catch {
  190.                 }
  191.                
  192.                 return isFullTrust;
  193.             }
  194.         }
  195.        
  196.         // Check if the type is allowed to be used in config by checking the APTCA bit
  197.         static internal bool IsTypeAllowedInConfig(Type t)
  198.         {
  199.             // Note:
  200.             // This code is copied from HttpRuntime.IsTypeAllowedInConfig, but modified in
  201.             // how it checks for fulltrust this can be called from non-ASP.NET apps.
  202.            
  203.             // Allow everything in full trust
  204.             if (IsCallerFullTrust) {
  205.                 return true;
  206.             }
  207.            
  208.             Assembly assembly = t.Assembly;
  209.             if (!assembly.GlobalAssemblyCache)
  210.                 return true;
  211.            
  212.             // If it has the APTCA bit, allow it
  213.             if (HasAptcaBit(assembly))
  214.                 return true;
  215.            
  216.             // It's a GAC type without APTCA in partial trust scenario: block it
  217.             return false;
  218.         }
  219.     }
  220. }

Developer Fusion