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

  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. // SecurityPermission.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.Threading;
  24.     using System.Runtime.Remoting;
  25.     using System.Security;
  26.     using System.Runtime.Serialization;
  27.     using System.Reflection;
  28.     using System.Globalization;
  29.    
  30.     [Flags(), Serializable()]
  31.     [System.Runtime.InteropServices.ComVisible(true)]
  32.     public enum SecurityPermissionFlag
  33.     {
  34.         NoFlags = 0,
  35. /* The following enum value is used in the EE (ASSERT_PERMISSION in security.cpp)
  36.         * Should this value change, make corresponding changes there
  37.         */       
  38.         Assertion = 1,
  39.         UnmanagedCode = 2,
  40.         // Update vm\Security.h if you change this !
  41.         SkipVerification = 4,
  42.         // Update vm\Security.h if you change this !
  43.         Execution = 8,
  44.         ControlThread = 16,
  45.         ControlEvidence = 32,
  46.         ControlPolicy = 64,
  47.         SerializationFormatter = 128,
  48.         ControlDomainPolicy = 256,
  49.         ControlPrincipal = 512,
  50.         ControlAppDomain = 1024,
  51.         RemotingConfiguration = 2048,
  52.         Infrastructure = 4096,
  53.         BindingRedirects = 8192,
  54.         AllFlags = 16383
  55.     }
  56.    
  57.     [System.Runtime.InteropServices.ComVisible(true)]
  58.     [Serializable()]
  59.     public sealed class SecurityPermission : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission
  60.     {
  61.         private SecurityPermissionFlag m_flags;
  62.        
  63.         //
  64.         // Public Constructors
  65.         //
  66.        
  67.         public SecurityPermission(PermissionState state)
  68.         {
  69.             if (state == PermissionState.Unrestricted) {
  70.                 SetUnrestricted(true);
  71.             }
  72.             else if (state == PermissionState.None) {
  73.                 SetUnrestricted(false);
  74.                 Reset();
  75.             }
  76.             else {
  77.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
  78.             }
  79.         }
  80.        
  81.        
  82.         // SecurityPermission
  83.         //
  84.         public SecurityPermission(SecurityPermissionFlag flag)
  85.         {
  86.             VerifyAccess(flag);
  87.            
  88.             SetUnrestricted(false);
  89.             m_flags = flag;
  90.         }
  91.        
  92.        
  93.         //------------------------------------------------------
  94.         //
  95.         // PRIVATE AND PROTECTED MODIFIERS
  96.         //
  97.         //------------------------------------------------------
  98.        
  99.        
  100.         private void SetUnrestricted(bool unrestricted)
  101.         {
  102.             if (unrestricted) {
  103.                 m_flags = SecurityPermissionFlag.AllFlags;
  104.             }
  105.         }
  106.        
  107.         private void Reset()
  108.         {
  109.             m_flags = SecurityPermissionFlag.NoFlags;
  110.         }
  111.        
  112.        
  113.         public SecurityPermissionFlag Flags {
  114.            
  115.            
  116.             get { return m_flags; }
  117.             set {
  118.                 VerifyAccess(value);
  119.                 m_flags = value;
  120.             }
  121.         }
  122.        
  123.         //
  124.         // CodeAccessPermission methods
  125.         //
  126.        
  127. /*
  128.         * IPermission interface implementation
  129.         */       
  130.        
  131.         public override bool IsSubsetOf(IPermission target)
  132.         {
  133.             if (target == null) {
  134.                 return m_flags == 0;
  135.             }
  136.            
  137.             SecurityPermission operand = target as SecurityPermission;
  138.             if (operand != null) {
  139.                 return (((int)this.m_flags) & ~((int)operand.m_flags)) == 0;
  140.             }
  141.             else {
  142.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName));
  143.             }
  144.            
  145.         }
  146.        
  147.         public override IPermission Union(IPermission target)
  148.         {
  149.             if (target == null)
  150.                 return (this.Copy());
  151.             if (!VerifyType(target)) {
  152.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName));
  153.             }
  154.             SecurityPermission sp_target = (SecurityPermission)target;
  155.             if (sp_target.IsUnrestricted() || IsUnrestricted()) {
  156.                 return (new SecurityPermission(PermissionState.Unrestricted));
  157.             }
  158.             SecurityPermissionFlag flag_union = (SecurityPermissionFlag)(m_flags | sp_target.m_flags);
  159.             return (new SecurityPermission(flag_union));
  160.         }
  161.        
  162.         public override IPermission Intersect(IPermission target)
  163.         {
  164.             if (target == null)
  165.                 return null;
  166.             else if (!VerifyType(target)) {
  167.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName));
  168.             }
  169.            
  170.             SecurityPermission operand = (SecurityPermission)target;
  171.             SecurityPermissionFlag isectFlags = SecurityPermissionFlag.NoFlags;
  172.            
  173.             if (operand.IsUnrestricted()) {
  174.                 if (this.IsUnrestricted())
  175.                     return new SecurityPermission(PermissionState.Unrestricted);
  176.                 else
  177.                     isectFlags = (SecurityPermissionFlag)this.m_flags;
  178.             }
  179.             else if (this.IsUnrestricted()) {
  180.                 isectFlags = (SecurityPermissionFlag)operand.m_flags;
  181.             }
  182.             else {
  183.                 isectFlags = (SecurityPermissionFlag)m_flags & (SecurityPermissionFlag)operand.m_flags;
  184.             }
  185.            
  186.             if (isectFlags == 0)
  187.                 return null;
  188.             else
  189.                 return new SecurityPermission(isectFlags);
  190.         }
  191.        
  192.         public override IPermission Copy()
  193.         {
  194.             if (IsUnrestricted())
  195.                 return new SecurityPermission(PermissionState.Unrestricted);
  196.             else
  197.                 return new SecurityPermission((SecurityPermissionFlag)m_flags);
  198.         }
  199.        
  200.         public bool IsUnrestricted()
  201.         {
  202.             return m_flags == SecurityPermissionFlag.AllFlags;
  203.         }
  204.        
  205.         private void VerifyAccess(SecurityPermissionFlag type)
  206.         {
  207.             if ((type & ~SecurityPermissionFlag.AllFlags) != 0)
  208.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Arg_EnumIllegalVal"), (int)type));
  209.         }
  210.        
  211.        
  212.         //------------------------------------------------------
  213.         //
  214.         // PUBLIC ENCODING METHODS
  215.         //
  216.         //------------------------------------------------------
  217.        
  218.         private const string _strHeaderAssertion = "Assertion";
  219.         private const string _strHeaderUnmanagedCode = "UnmanagedCode";
  220.         private const string _strHeaderExecution = "Execution";
  221.         private const string _strHeaderSkipVerification = "SkipVerification";
  222.         private const string _strHeaderControlThread = "ControlThread";
  223.         private const string _strHeaderControlEvidence = "ControlEvidence";
  224.         private const string _strHeaderControlPolicy = "ControlPolicy";
  225.         private const string _strHeaderSerializationFormatter = "SerializationFormatter";
  226.         private const string _strHeaderControlDomainPolicy = "ControlDomainPolicy";
  227.         private const string _strHeaderControlPrincipal = "ControlPrincipal";
  228.         private const string _strHeaderControlAppDomain = "ControlAppDomain";
  229.        
  230.         public override SecurityElement ToXml()
  231.         {
  232.             SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.SecurityPermission");
  233.             if (!IsUnrestricted()) {
  234.                 esd.AddAttribute("Flags", XMLUtil.BitFieldEnumToString(typeof(SecurityPermissionFlag), m_flags));
  235.             }
  236.             else {
  237.                 esd.AddAttribute("Unrestricted", "true");
  238.             }
  239.             return esd;
  240.         }
  241.        
  242.         public override void FromXml(SecurityElement esd)
  243.         {
  244.             CodeAccessPermission.ValidateElement(esd, this);
  245.             if (XMLUtil.IsUnrestricted(esd)) {
  246.                 m_flags = SecurityPermissionFlag.AllFlags;
  247.                 return;
  248.             }
  249.            
  250.             Reset();
  251.             SetUnrestricted(false);
  252.            
  253.             string flags = esd.Attribute("Flags");
  254.            
  255.             if (flags != null)
  256.                 m_flags = (SecurityPermissionFlag)Enum.Parse(typeof(SecurityPermissionFlag), flags);
  257.         }
  258.        
  259.         //
  260.         // Object Overrides
  261.         //
  262.        
  263.        
  264.         /// <internalonly/>
  265.         int IBuiltInPermission.GetTokenIndex()
  266.         {
  267.             return SecurityPermission.GetTokenIndex();
  268.         }
  269.        
  270.         static internal int GetTokenIndex()
  271.         {
  272.             return BuiltInPermissionIndex.SecurityPermissionIndex;
  273.         }
  274.        
  275.         // This can be used as a place-holder for SkipVerification permission
  276.         [SecurityPermission(SecurityAction.LinkDemand, SkipVerification = true)]
  277.         static internal void MethodWithSkipVerificationLinkDemand()
  278.         {
  279.         }
  280.     }
  281.    
  282.    
  283. }

Developer Fusion