The Labs \ Source Viewer \ SSCLI \ System.Security.Permissions \ ReflectionPermission

  1. // ==++==
  2. //
  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. //
  14. // ==--==
  15. // ReflectionPermission.cs
  16. //
  17. namespace System.Security.Permissions
  18. {
  19.     using System;
  20.     using System.IO;
  21.     using System.Security.Util;
  22.     using System.Text;
  23.     using System.Runtime.Remoting;
  24.     using System.Security;
  25.     using System.Reflection;
  26.     using System.Globalization;
  27.    
  28.     [Flags(), Serializable()]
  29.     [System.Runtime.InteropServices.ComVisible(true)]
  30.     public enum ReflectionPermissionFlag
  31.     {
  32.         NoFlags = 0,
  33.         [Obsolete("This API has been deprecated. http://go.microsoft.com/fwlink/?linkid=14202")]
  34.         TypeInformation = 1,
  35.         MemberAccess = 2,
  36.         ReflectionEmit = 4,
  37.         AllFlags = 7
  38.     }
  39.    
  40.     [System.Runtime.InteropServices.ComVisible(true)]
  41.     [Serializable()]
  42.     public sealed class ReflectionPermission : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission
  43.     {
  44.        
  45.         private ReflectionPermissionFlag m_flags;
  46.        
  47.         //
  48.         // Public Constructors
  49.         //
  50.        
  51.         public ReflectionPermission(PermissionState state)
  52.         {
  53.             if (state == PermissionState.Unrestricted) {
  54.                 SetUnrestricted(true);
  55.             }
  56.             else if (state == PermissionState.None) {
  57.                 SetUnrestricted(false);
  58.                 Reset();
  59.             }
  60.             else {
  61.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
  62.             }
  63.         }
  64.        
  65.         // Parameters:
  66.         //
  67.         public ReflectionPermission(ReflectionPermissionFlag flag)
  68.         {
  69.             VerifyAccess(flag);
  70.            
  71.             SetUnrestricted(false);
  72.             m_flags = flag;
  73.         }
  74.        
  75.         //------------------------------------------------------
  76.         //
  77.         // PRIVATE AND PROTECTED MODIFIERS
  78.         //
  79.         //------------------------------------------------------
  80.        
  81.        
  82.         private void SetUnrestricted(bool unrestricted)
  83.         {
  84.             if (unrestricted) {
  85.                 m_flags = ReflectionPermissionFlag.AllFlags;
  86.             }
  87.             else {
  88.                 Reset();
  89.             }
  90.         }
  91.        
  92.        
  93.         private void Reset()
  94.         {
  95.             m_flags = ReflectionPermissionFlag.NoFlags;
  96.         }
  97.        
  98.        
  99.         public ReflectionPermissionFlag Flags {
  100.            
  101.            
  102.             get { return m_flags; }
  103.             set {
  104.                 VerifyAccess(value);
  105.                 m_flags = value;
  106.             }
  107.         }
  108.        
  109.        
  110.        
  111.        
  112.         //
  113.         // CodeAccessPermission implementation
  114.         //
  115.        
  116.         public bool IsUnrestricted()
  117.         {
  118.             return m_flags == ReflectionPermissionFlag.AllFlags;
  119.         }
  120.        
  121.         //
  122.         // IPermission implementation
  123.         //
  124.        
  125.         public override IPermission Union(IPermission other)
  126.         {
  127.             if (other == null) {
  128.                 return this.Copy();
  129.             }
  130.             else if (!VerifyType(other)) {
  131.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName));
  132.             }
  133.            
  134.             ReflectionPermission operand = (ReflectionPermission)other;
  135.            
  136.             if (this.IsUnrestricted() || operand.IsUnrestricted()) {
  137.                 return new ReflectionPermission(PermissionState.Unrestricted);
  138.             }
  139.             else {
  140.                 ReflectionPermissionFlag flag_union = (ReflectionPermissionFlag)(m_flags | operand.m_flags);
  141.                 return (new ReflectionPermission(flag_union));
  142.             }
  143.         }
  144.        
  145.        
  146.        
  147.         public override bool IsSubsetOf(IPermission target)
  148.         {
  149.             if (target == null) {
  150.                 return m_flags == ReflectionPermissionFlag.NoFlags;
  151.             }
  152.            
  153.             try {
  154.                 ReflectionPermission operand = (ReflectionPermission)target;
  155.                 if (operand.IsUnrestricted())
  156.                     return true;
  157.                 else if (this.IsUnrestricted())
  158.                     return false;
  159.                 else
  160.                     return (((int)this.m_flags) & ~((int)operand.m_flags)) == 0;
  161.             }
  162.             catch (InvalidCastException) {
  163.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName));
  164.             }
  165.            
  166.         }
  167.        
  168.         public override IPermission Intersect(IPermission target)
  169.         {
  170.             if (target == null)
  171.                 return null;
  172.             else if (!VerifyType(target)) {
  173.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName));
  174.             }
  175.            
  176.             ReflectionPermission operand = (ReflectionPermission)target;
  177.            
  178.             ReflectionPermissionFlag newFlags = operand.m_flags & this.m_flags;
  179.            
  180.             if (newFlags == ReflectionPermissionFlag.NoFlags)
  181.                 return null;
  182.             else
  183.                 return new ReflectionPermission(newFlags);
  184.         }
  185.        
  186.         public override IPermission Copy()
  187.         {
  188.             if (this.IsUnrestricted()) {
  189.                 return new ReflectionPermission(PermissionState.Unrestricted);
  190.             }
  191.             else {
  192.                 return new ReflectionPermission((ReflectionPermissionFlag)m_flags);
  193.             }
  194.         }
  195.        
  196.        
  197.         //
  198.         // IEncodable Interface
  199.        
  200.         private void VerifyAccess(ReflectionPermissionFlag type)
  201.         {
  202.             if ((type & ~ReflectionPermissionFlag.AllFlags) != 0)
  203.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Arg_EnumIllegalVal"), (int)type));
  204.         }
  205.        
  206.        
  207.         //------------------------------------------------------
  208.         //
  209.         // PUBLIC ENCODING METHODS
  210.         //
  211.         //------------------------------------------------------
  212.        
  213.         private const string _strHeaderTypeInformation = "TypeInformation";
  214.         private const string _strHeaderMemberAccess = "MemberAccess";
  215.         private const string _strHeaderReflectionEmit = "ReflectionEmit";
  216.        
  217.         public override SecurityElement ToXml()
  218.         {
  219.             SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.ReflectionPermission");
  220.             if (!IsUnrestricted()) {
  221.                 esd.AddAttribute("Flags", XMLUtil.BitFieldEnumToString(typeof(ReflectionPermissionFlag), m_flags));
  222.             }
  223.             else {
  224.                 esd.AddAttribute("Unrestricted", "true");
  225.             }
  226.             return esd;
  227.         }
  228.        
  229.         public override void FromXml(SecurityElement esd)
  230.         {
  231.             CodeAccessPermission.ValidateElement(esd, this);
  232.             if (XMLUtil.IsUnrestricted(esd)) {
  233.                 m_flags = ReflectionPermissionFlag.AllFlags;
  234.                 return;
  235.             }
  236.            
  237.             Reset();
  238.             SetUnrestricted(false);
  239.            
  240.             string flags = esd.Attribute("Flags");
  241.             if (flags != null)
  242.                 m_flags = (ReflectionPermissionFlag)Enum.Parse(typeof(ReflectionPermissionFlag), flags);
  243.         }
  244.        
  245.         /// <internalonly/>
  246.         int IBuiltInPermission.GetTokenIndex()
  247.         {
  248.             return ReflectionPermission.GetTokenIndex();
  249.         }
  250.        
  251.         static internal int GetTokenIndex()
  252.         {
  253.             return BuiltInPermissionIndex.ReflectionPermissionIndex;
  254.         }
  255.        
  256.        
  257.     }
  258.    
  259. }

Developer Fusion