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

  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. // UrlIdentityPermission.cs
  16. //
  17. namespace System.Security.Permissions
  18. {
  19.     using System;
  20.     using SecurityElement = System.Security.SecurityElement;
  21.     using System.Security.Util;
  22.     using System.IO;
  23.     using System.Text;
  24.     using System.Collections;
  25.     using System.Globalization;
  26.     using System.Runtime.Serialization;
  27.    
  28.     [System.Runtime.InteropServices.ComVisible(true)]
  29.     [Serializable()]
  30.     public sealed class UrlIdentityPermission : CodeAccessPermission, IBuiltInPermission
  31.     {
  32.         //------------------------------------------------------
  33.         //
  34.         // PRIVATE STATE DATA
  35.         //
  36.         //------------------------------------------------------
  37.        
  38.         [OptionalField(VersionAdded = 2)]
  39.         private bool m_unrestricted;
  40.         [OptionalField(VersionAdded = 2)]
  41.         private URLString[] m_urls;
  42.        
  43.         // This field will be populated only for non X-AD scenarios where we create a XML-ised string of the Permission
  44.         [OptionalField(VersionAdded = 2)]
  45.         private string m_serializedPermission;
  46.        
  47.         // This field is legacy info from v1.x and is never used in v2.0 and beyond: purely for serialization purposes
  48.         private URLString m_url;
  49.        
  50.        
  51.         [OnDeserialized()]
  52.         private void OnDeserialized(StreamingContext ctx)
  53.         {
  54.             // v2.0 and beyond XML case
  55.             if (m_serializedPermission != null) {
  56.                 FromXml(SecurityElement.FromString(m_serializedPermission));
  57.                 m_serializedPermission = null;
  58.             }
  59.             //v1.x case where we read the m_site value
  60.             else if (m_url != null) {
  61.                 m_unrestricted = false;
  62.                 m_urls = new URLString[1];
  63.                 m_urls[0] = m_url;
  64.                 m_url = null;
  65.             }
  66.            
  67.         }
  68.        
  69.         [OnSerializing()]
  70.         private void OnSerializing(StreamingContext ctx)
  71.         {
  72.            
  73.             if ((ctx.State & ~(StreamingContextStates.Clone | StreamingContextStates.CrossAppDomain)) != 0) {
  74.                 m_serializedPermission = ToXml().ToString();
  75.                 //for the v2 and beyond case
  76.                 if (m_urls != null && m_urls.Length == 1)
  77.                     // for the v1.x case
  78.                     m_url = m_urls[0];
  79.                
  80.             }
  81.         }
  82.         [OnSerialized()]
  83.         private void OnSerialized(StreamingContext ctx)
  84.         {
  85.             if ((ctx.State & ~(StreamingContextStates.Clone | StreamingContextStates.CrossAppDomain)) != 0) {
  86.                 m_serializedPermission = null;
  87.                 m_url = null;
  88.             }
  89.         }
  90.        
  91.        
  92.         //------------------------------------------------------
  93.         //
  94.         // PUBLIC CONSTRUCTORS
  95.         //
  96.         //------------------------------------------------------
  97.        
  98.        
  99.         public UrlIdentityPermission(PermissionState state)
  100.         {
  101.             if (state == PermissionState.Unrestricted) {
  102.                 if (CodeAccessSecurityEngine.DoesFullTrustMeanFullTrust())
  103.                     m_unrestricted = true;
  104.                 else
  105.                     throw new ArgumentException(Environment.GetResourceString("Argument_UnrestrictedIdentityPermission"));
  106.             }
  107.             else if (state == PermissionState.None) {
  108.                 m_unrestricted = false;
  109.             }
  110.             else {
  111.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
  112.             }
  113.         }
  114.        
  115.         public UrlIdentityPermission(string site)
  116.         {
  117.             if (site == null)
  118.                 throw new ArgumentNullException("site");
  119.             Url = site;
  120.         }
  121.        
  122.         internal UrlIdentityPermission(URLString site)
  123.         {
  124.             m_unrestricted = false;
  125.             m_urls = new URLString[1];
  126.             m_urls[0] = site;
  127.         }
  128.        
  129.         //------------------------------------------------------
  130.         //
  131.         // PUBLIC ACCESSOR METHODS
  132.         //
  133.         //------------------------------------------------------
  134.        
  135.         public string Url {
  136.            
  137.             get {
  138.                 if (m_urls == null)
  139.                     return "";
  140.                 if (m_urls.Length == 1)
  141.                     return m_urls[0].ToString();
  142.                 throw new NotSupportedException(Environment.GetResourceString("NotSupported_AmbiguousIdentity"));
  143.             }
  144.             set {
  145.                 m_unrestricted = false;
  146.                 if (value == null || value.Length == 0)
  147.                     m_urls = null;
  148.                 else {
  149.                     m_urls = new URLString[1];
  150.                     m_urls[0] = new URLString(value);
  151.                 }
  152.             }
  153.         }
  154.        
  155.         //------------------------------------------------------
  156.         //
  157.         // PRIVATE AND PROTECTED HELPERS FOR ACCESSORS AND CONSTRUCTORS
  158.         //
  159.         //------------------------------------------------------
  160.        
  161.         //------------------------------------------------------
  162.         //
  163.         // CODEACCESSPERMISSION IMPLEMENTATION
  164.         //
  165.         //------------------------------------------------------
  166.        
  167.         //------------------------------------------------------
  168.         //
  169.         // IPERMISSION IMPLEMENTATION
  170.         //
  171.         //------------------------------------------------------
  172.        
  173.        
  174.         public override IPermission Copy()
  175.         {
  176.             UrlIdentityPermission perm = new UrlIdentityPermission(PermissionState.None);
  177.             perm.m_unrestricted = this.m_unrestricted;
  178.             if (this.m_urls != null) {
  179.                 perm.m_urls = new URLString[this.m_urls.Length];
  180.                 int n;
  181.                 for (n = 0; n < this.m_urls.Length; n++)
  182.                     perm.m_urls[n] = (URLString)this.m_urls[n].Copy();
  183.             }
  184.             return perm;
  185.         }
  186.        
  187.         public override bool IsSubsetOf(IPermission target)
  188.         {
  189.             if (target == null) {
  190.                 if (m_unrestricted)
  191.                     return false;
  192.                 if (m_urls == null)
  193.                     return true;
  194.                 if (m_urls.Length == 0)
  195.                     return true;
  196.                 return false;
  197.             }
  198.             UrlIdentityPermission that = target as UrlIdentityPermission;
  199.             if (that == null)
  200.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName));
  201.             if (that.m_unrestricted)
  202.                 return true;
  203.             if (m_unrestricted)
  204.                 return false;
  205.             if (this.m_urls != null) {
  206.                 foreach (URLString usThis in this.m_urls) {
  207.                     bool bOK = false;
  208.                     if (that.m_urls != null) {
  209.                         foreach (URLString usThat in that.m_urls) {
  210.                             if (usThis.IsSubsetOf(usThat)) {
  211.                                 bOK = true;
  212.                                 break;
  213.                             }
  214.                         }
  215.                     }
  216.                     if (!bOK)
  217.                         return false;
  218.                 }
  219.             }
  220.             return true;
  221.         }
  222.        
  223.         public override IPermission Intersect(IPermission target)
  224.         {
  225.             if (target == null)
  226.                 return null;
  227.             UrlIdentityPermission that = target as UrlIdentityPermission;
  228.             if (that == null)
  229.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName));
  230.             if (this.m_unrestricted && that.m_unrestricted) {
  231.                 UrlIdentityPermission res = new UrlIdentityPermission(PermissionState.None);
  232.                 res.m_unrestricted = true;
  233.                 return res;
  234.             }
  235.             if (this.m_unrestricted)
  236.                 return that.Copy();
  237.             if (that.m_unrestricted)
  238.                 return this.Copy();
  239.             if (this.m_urls == null || that.m_urls == null || this.m_urls.Length == 0 || that.m_urls.Length == 0)
  240.                 return null;
  241.             ArrayList alUrls = new ArrayList();
  242.             foreach (URLString usThis in this.m_urls) {
  243.                 foreach (URLString usThat in that.m_urls) {
  244.                     URLString usInt = (URLString)usThis.Intersect(usThat);
  245.                     if (usInt != null)
  246.                         alUrls.Add(usInt);
  247.                 }
  248.             }
  249.             if (alUrls.Count == 0)
  250.                 return null;
  251.             UrlIdentityPermission result = new UrlIdentityPermission(PermissionState.None);
  252.             result.m_urls = (URLString[])alUrls.ToArray(typeof(URLString));
  253.             return result;
  254.         }
  255.        
  256.         public override IPermission Union(IPermission target)
  257.         {
  258.             if (target == null) {
  259.                 if ((this.m_urls == null || this.m_urls.Length == 0) && !this.m_unrestricted)
  260.                     return null;
  261.                 return this.Copy();
  262.             }
  263.             UrlIdentityPermission that = target as UrlIdentityPermission;
  264.             if (that == null)
  265.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName));
  266.             if (this.m_unrestricted || that.m_unrestricted) {
  267.                 UrlIdentityPermission res = new UrlIdentityPermission(PermissionState.None);
  268.                 res.m_unrestricted = true;
  269.                 return res;
  270.             }
  271.             if (this.m_urls == null || this.m_urls.Length == 0) {
  272.                 if (that.m_urls == null || that.m_urls.Length == 0)
  273.                     return null;
  274.                 return that.Copy();
  275.             }
  276.             if (that.m_urls == null || that.m_urls.Length == 0)
  277.                 return this.Copy();
  278.             ArrayList alUrls = new ArrayList();
  279.             foreach (URLString usThis in this.m_urls)
  280.                 alUrls.Add(usThis);
  281.             foreach (URLString usThat in that.m_urls) {
  282.                 bool bDupe = false;
  283.                 foreach (URLString us in alUrls) {
  284.                     if (usThat.Equals(us)) {
  285.                         bDupe = true;
  286.                         break;
  287.                     }
  288.                 }
  289.                 if (!bDupe)
  290.                     alUrls.Add(usThat);
  291.             }
  292.             UrlIdentityPermission result = new UrlIdentityPermission(PermissionState.None);
  293.             result.m_urls = (URLString[])alUrls.ToArray(typeof(URLString));
  294.             return result;
  295.         }
  296.        
  297.         public override void FromXml(SecurityElement esd)
  298.         {
  299.             m_unrestricted = false;
  300.             m_urls = null;
  301.             CodeAccessPermission.ValidateElement(esd, this);
  302.             string unr = esd.Attribute("Unrestricted");
  303.             if (unr != null && String.Compare(unr, "true", StringComparison.OrdinalIgnoreCase) == 0) {
  304.                 m_unrestricted = true;
  305.                 return;
  306.             }
  307.             string elem = esd.Attribute("Url");
  308.             ArrayList al = new ArrayList();
  309.             if (elem != null)
  310.                 al.Add(new URLString(elem, true));
  311.             ArrayList alChildren = esd.Children;
  312.             if (alChildren != null) {
  313.                 foreach (SecurityElement child in alChildren) {
  314.                     elem = child.Attribute("Url");
  315.                     if (elem != null)
  316.                         al.Add(new URLString(elem, true));
  317.                 }
  318.             }
  319.             if (al.Count != 0)
  320.                 m_urls = (URLString[])al.ToArray(typeof(URLString));
  321.         }
  322.        
  323.         public override SecurityElement ToXml()
  324.         {
  325.             SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.UrlIdentityPermission");
  326.             if (m_unrestricted)
  327.                 esd.AddAttribute("Unrestricted", "true");
  328.             else if (m_urls != null) {
  329.                 if (m_urls.Length == 1)
  330.                     esd.AddAttribute("Url", m_urls[0].ToString());
  331.                 else {
  332.                     int n;
  333.                     for (n = 0; n < m_urls.Length; n++) {
  334.                         SecurityElement child = new SecurityElement("Url");
  335.                         child.AddAttribute("Url", m_urls[n].ToString());
  336.                         esd.AddChild(child);
  337.                     }
  338.                 }
  339.             }
  340.             return esd;
  341.         }
  342.        
  343.         /// <internalonly/>
  344.         int IBuiltInPermission.GetTokenIndex()
  345.         {
  346.             return UrlIdentityPermission.GetTokenIndex();
  347.         }
  348.        
  349.         static internal int GetTokenIndex()
  350.         {
  351.             return BuiltInPermissionIndex.UrlIdentityPermissionIndex;
  352.         }
  353.     }
  354. }

Developer Fusion