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

  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. // ZoneIdentityPermission.cs
  16. //
  17. namespace System.Security.Permissions
  18. {
  19.     using System;
  20.     using SecurityElement = System.Security.SecurityElement;
  21.     using System.Globalization;
  22.     using System.Runtime.Serialization;
  23.    
  24.     [System.Runtime.InteropServices.ComVisible(true)]
  25.     [Serializable()]
  26.     public sealed class ZoneIdentityPermission : CodeAccessPermission, IBuiltInPermission
  27.     {
  28.         //------------------------------------------------------
  29.         //
  30.         // PRIVATE STATE DATA
  31.         //
  32.         //------------------------------------------------------
  33.        
  34.         // Zone Enum Flag
  35.         // ----- ----- -----
  36.         // NoZone -1 0x00
  37.         // MyComputer 0 0x01 (1 << 0)
  38.         // Intranet 1 0x02 (1 << 1)
  39.         // Trusted 2 0x04 (1 << 2)
  40.         // Internet 3 0x08 (1 << 3)
  41.         // Untrusted 4 0x10 (1 << 4)
  42.        
  43.         private const uint AllZones = 31;
  44.         [OptionalField(VersionAdded = 2)]
  45.         private uint m_zones;
  46.        
  47.         // This field will be populated only for non X-AD scenarios where we create a XML-ised string of the Permission
  48.         [OptionalField(VersionAdded = 2)]
  49.         private string m_serializedPermission;
  50.        
  51.         // This field is legacy info from v1.x and is never used in v2.0 and beyond: purely for serialization purposes
  52.         private SecurityZone m_zone = SecurityZone.NoZone;
  53.        
  54.        
  55.         [OnDeserialized()]
  56.         private void OnDeserialized(StreamingContext ctx)
  57.         {
  58.             if ((ctx.State & ~(StreamingContextStates.Clone | StreamingContextStates.CrossAppDomain)) != 0) {
  59.                 // v2.0 and beyond XML case
  60.                 if (m_serializedPermission != null) {
  61.                     FromXml(SecurityElement.FromString(m_serializedPermission));
  62.                     m_serializedPermission = null;
  63.                 }
  64.                 //v1.x case where we read the m_zone value
  65.                 else {
  66.                     SecurityZone = m_zone;
  67.                     m_zone = SecurityZone.NoZone;
  68.                 }
  69.             }
  70.            
  71.            
  72.         }
  73.        
  74.         [OnSerializing()]
  75.         private void OnSerializing(StreamingContext ctx)
  76.         {
  77.            
  78.             if ((ctx.State & ~(StreamingContextStates.Clone | StreamingContextStates.CrossAppDomain)) != 0) {
  79.                 m_serializedPermission = ToXml().ToString();
  80.                 //for the v2 and beyond case
  81.                 m_zone = SecurityZone;
  82.                
  83.             }
  84.         }
  85.         [OnSerialized()]
  86.         private void OnSerialized(StreamingContext ctx)
  87.         {
  88.             if ((ctx.State & ~(StreamingContextStates.Clone | StreamingContextStates.CrossAppDomain)) != 0) {
  89.                 m_serializedPermission = null;
  90.                 m_zone = SecurityZone.NoZone;
  91.             }
  92.         }
  93.        
  94.         //------------------------------------------------------
  95.         //
  96.         // PUBLIC CONSTRUCTORS
  97.         //
  98.         //------------------------------------------------------
  99.        
  100.         public ZoneIdentityPermission(PermissionState state)
  101.         {
  102.             if (state == PermissionState.Unrestricted) {
  103.                 if (CodeAccessSecurityEngine.DoesFullTrustMeanFullTrust())
  104.                     m_zones = AllZones;
  105.                 else
  106.                     throw new ArgumentException(Environment.GetResourceString("Argument_UnrestrictedIdentityPermission"));
  107.             }
  108.             else if (state == PermissionState.None) {
  109.                 m_zones = 0;
  110.             }
  111.             else {
  112.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
  113.             }
  114.         }
  115.        
  116.         public ZoneIdentityPermission(SecurityZone zone)
  117.         {
  118.             this.SecurityZone = zone;
  119.         }
  120.        
  121.         internal ZoneIdentityPermission(uint zones)
  122.         {
  123.             m_zones = (zones & AllZones);
  124.         }
  125.        
  126.         //------------------------------------------------------
  127.         //
  128.         // PUBLIC ACCESSOR METHODS
  129.         //
  130.         //------------------------------------------------------
  131.        
  132.         public SecurityZone SecurityZone {
  133.            
  134.             get {
  135.                 SecurityZone z = SecurityZone.NoZone;
  136.                 int nEnum = 0;
  137.                 uint nFlag;
  138.                 for (nFlag = 1; nFlag < AllZones; nFlag <<= 1) {
  139.                     if ((m_zones & nFlag) != 0) {
  140.                         if (z == SecurityZone.NoZone)
  141.                             z = (SecurityZone)nEnum;
  142.                         else
  143.                             return SecurityZone.NoZone;
  144.                     }
  145.                     nEnum++;
  146.                 }
  147.                 return z;
  148.             }
  149.             set {
  150.                 VerifyZone(value);
  151.                 if (value == SecurityZone.NoZone)
  152.                     m_zones = 0;
  153.                 else
  154.                     m_zones = (uint)1 << (int)value;
  155.             }
  156.         }
  157.        
  158.         //------------------------------------------------------
  159.         //
  160.         // PRIVATE AND PROTECTED HELPERS FOR ACCESSORS AND CONSTRUCTORS
  161.         //
  162.         //------------------------------------------------------
  163.        
  164.         private static void VerifyZone(SecurityZone zone)
  165.         {
  166.             if (zone < SecurityZone.NoZone || zone > SecurityZone.Untrusted) {
  167.                 throw new ArgumentException(Environment.GetResourceString("Argument_IllegalZone"));
  168.             }
  169.         }
  170.        
  171.        
  172.         //------------------------------------------------------
  173.         //
  174.         // CODEACCESSPERMISSION IMPLEMENTATION
  175.         //
  176.         //------------------------------------------------------
  177.        
  178.         //------------------------------------------------------
  179.         //
  180.         // IPERMISSION IMPLEMENTATION
  181.         //
  182.         //------------------------------------------------------
  183.        
  184.        
  185.         public override IPermission Copy()
  186.         {
  187.             return new ZoneIdentityPermission(this.m_zones);
  188.         }
  189.        
  190.         public override bool IsSubsetOf(IPermission target)
  191.         {
  192.             if (target == null)
  193.                 return this.m_zones == 0;
  194.            
  195.             ZoneIdentityPermission that = target as ZoneIdentityPermission;
  196.             if (that == null)
  197.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName));
  198.             return (this.m_zones & that.m_zones) == this.m_zones;
  199.         }
  200.        
  201.         public override IPermission Intersect(IPermission target)
  202.         {
  203.             if (target == null)
  204.                 return null;
  205.            
  206.             ZoneIdentityPermission that = target as ZoneIdentityPermission;
  207.             if (that == null)
  208.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName));
  209.             uint newZones = this.m_zones & that.m_zones;
  210.             if (newZones == 0)
  211.                 return null;
  212.             return new ZoneIdentityPermission(newZones);
  213.         }
  214.        
  215.         public override IPermission Union(IPermission target)
  216.         {
  217.             if (target == null)
  218.                 return this.m_zones != 0 ? this.Copy() : null;
  219.            
  220.             ZoneIdentityPermission that = target as ZoneIdentityPermission;
  221.             if (that == null)
  222.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName));
  223.             return new ZoneIdentityPermission(this.m_zones | that.m_zones);
  224.         }
  225.        
  226.         public override SecurityElement ToXml()
  227.         {
  228.             SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.ZoneIdentityPermission");
  229.             if (SecurityZone != SecurityZone.NoZone) {
  230.                 esd.AddAttribute("Zone", Enum.GetName(typeof(SecurityZone), this.SecurityZone));
  231.             }
  232.             else {
  233.                 int nEnum = 0;
  234.                 uint nFlag;
  235.                 for (nFlag = 1; nFlag < AllZones; nFlag <<= 1) {
  236.                     if ((m_zones & nFlag) != 0) {
  237.                         SecurityElement child = new SecurityElement("Zone");
  238.                         child.AddAttribute("Zone", Enum.GetName(typeof(SecurityZone), (SecurityZone)nEnum));
  239.                         esd.AddChild(child);
  240.                     }
  241.                     nEnum++;
  242.                 }
  243.             }
  244.             return esd;
  245.         }
  246.        
  247.         public override void FromXml(SecurityElement esd)
  248.         {
  249.             m_zones = 0;
  250.             CodeAccessPermission.ValidateElement(esd, this);
  251.             string eZone = esd.Attribute("Zone");
  252.             if (eZone != null)
  253.                 SecurityZone = (SecurityZone)Enum.Parse(typeof(SecurityZone), eZone);
  254.             if (esd.Children != null) {
  255.                 foreach (SecurityElement child in esd.Children) {
  256.                     eZone = child.Attribute("Zone");
  257.                     int enm = (int)Enum.Parse(typeof(SecurityZone), eZone);
  258.                     if (enm == (int)SecurityZone.NoZone)
  259.                         continue;
  260.                     m_zones |= ((uint)1 << enm);
  261.                 }
  262.             }
  263.         }
  264.        
  265.         /// <internalonly/>
  266.         int IBuiltInPermission.GetTokenIndex()
  267.         {
  268.             return ZoneIdentityPermission.GetTokenIndex();
  269.         }
  270.        
  271.         static internal int GetTokenIndex()
  272.         {
  273.             return BuiltInPermissionIndex.ZoneIdentityPermissionIndex;
  274.         }
  275.        
  276.     }
  277. }

Developer Fusion