We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Security.Policy \ PolicyStatementAttribute

SSCLI
  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. // PolicyStatement.cs
  16. //
  17. // Represents the policy associated with some piece of evidence
  18. //
  20. namespace System.Security.Policy
  21. {
  22.    
  23.     using System;
  24.     using System.Security;
  25.     using System.Security.Util;
  26.     using Math = System.Math;
  27.     using System.Collections;
  28.     using System.Security.Permissions;
  29.     using System.Text;
  30.     using System.Runtime.Remoting.Activation;
  31.     using System.Globalization;
  32.     [Flags(), Serializable()]
  33.     [System.Runtime.InteropServices.ComVisible(true)]
  34.     public enum PolicyStatementAttribute
  35.     {
  36.         Nothing = 0,
  37.         Exclusive = 1,
  38.         LevelFinal = 2,
  39.         All = 3
  40.     }
  41.    
  42.     [Serializable()]
  43.     [System.Runtime.InteropServices.ComVisible(true)]
  44.     public sealed class PolicyStatement : ISecurityEncodable, ISecurityPolicyEncodable
  45.     {
  46.         // The PermissionSet associated with this policy
  47.         internal PermissionSet m_permSet;
  48.        
  49.         // The bitfield of inheritance properties associated with this policy
  50.         internal PolicyStatementAttribute m_attributes;
  51.        
  52.         internal PolicyStatement()
  53.         {
  54.             m_permSet = null;
  55.             m_attributes = PolicyStatementAttribute.Nothing;
  56.         }
  57.        
  58.         public PolicyStatement(PermissionSet permSet) : this(permSet, PolicyStatementAttribute.Nothing)
  59.         {
  60.         }
  61.        
  62.         public PolicyStatement(PermissionSet permSet, PolicyStatementAttribute attributes)
  63.         {
  64.             if (permSet == null) {
  65.                 m_permSet = new PermissionSet(false);
  66.             }
  67.             else {
  68.                 m_permSet = permSet.Copy();
  69.             }
  70.             if (ValidProperties(attributes)) {
  71.                 m_attributes = attributes;
  72.             }
  73.         }
  74.        
  75.         private PolicyStatement(PermissionSet permSet, PolicyStatementAttribute attributes, bool copy)
  76.         {
  77.             if (permSet != null) {
  78.                 if (copy)
  79.                     m_permSet = permSet.Copy();
  80.                 else
  81.                     m_permSet = permSet;
  82.             }
  83.             else {
  84.                 m_permSet = new PermissionSet(false);
  85.             }
  86.            
  87.             m_attributes = attributes;
  88.         }
  89.        
  90.        
  91.         public PermissionSet PermissionSet {
  92.             get {
  93.                 lock (this) {
  94.                     return m_permSet.Copy();
  95.                 }
  96.             }
  97.            
  98.             set {
  99.                 lock (this) {
  100.                     if (value == null) {
  101.                         m_permSet = new PermissionSet(false);
  102.                     }
  103.                     else {
  104.                         m_permSet = value.Copy();
  105.                     }
  106.                 }
  107.             }
  108.         }
  109.        
  110.         internal void SetPermissionSetNoCopy(PermissionSet permSet)
  111.         {
  112.             m_permSet = permSet;
  113.         }
  114.        
  115.         internal PermissionSet GetPermissionSetNoCopy()
  116.         {
  117.             lock (this) {
  118.                 return m_permSet;
  119.             }
  120.         }
  121.        
  122.         public PolicyStatementAttribute Attributes {
  123.             get { return m_attributes; }
  124.            
  125.             set {
  126.                 if (ValidProperties(value)) {
  127.                     m_attributes = value;
  128.                 }
  129.             }
  130.         }
  131.        
  132.         public PolicyStatement Copy()
  133.         {
  134.             return new PolicyStatement(m_permSet, m_attributes, true);
  135.         }
  136.        
  137.         public string AttributeString {
  138.             get {
  139.                 StringBuilder sb = new StringBuilder();
  140.                
  141.                 bool first = true;
  142.                
  143.                 if (GetFlag((int)PolicyStatementAttribute.Exclusive)) {
  144.                     sb.Append("Exclusive");
  145.                     first = false;
  146.                 }
  147.                 if (GetFlag((int)PolicyStatementAttribute.LevelFinal)) {
  148.                     if (!first)
  149.                         sb.Append(" ");
  150.                     sb.Append("LevelFinal");
  151.                 }
  152.                
  153.                 return sb.ToString();
  154.             }
  155.         }
  156.        
  157.         private static bool ValidProperties(PolicyStatementAttribute attributes)
  158.         {
  159.             if ((attributes & ~(PolicyStatementAttribute.All)) == 0) {
  160.                 return true;
  161.             }
  162.             else {
  163.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidFlag"));
  164.             }
  165.         }
  166.        
  167.         private bool GetFlag(int flag)
  168.         {
  169.             return (flag & (int)m_attributes) != 0;
  170.         }
  171.        
  172.         public SecurityElement ToXml()
  173.         {
  174.             return ToXml(null);
  175.         }
  176.        
  177.         public void FromXml(SecurityElement et)
  178.         {
  179.             FromXml(et, null);
  180.         }
  181.        
  182.         public SecurityElement ToXml(PolicyLevel level)
  183.         {
  184.             return ToXml(level, false);
  185.         }
  186.        
  187.         internal SecurityElement ToXml(PolicyLevel level, bool useInternal)
  188.         {
  189.             SecurityElement e = new SecurityElement("PolicyStatement");
  190.             e.AddAttribute("version", "1");
  191.             if (m_attributes != PolicyStatementAttribute.Nothing)
  192.                 e.AddAttribute("Attributes", XMLUtil.BitFieldEnumToString(typeof(PolicyStatementAttribute), m_attributes));
  193.            
  194.             lock (this) {
  195.                 if (m_permSet != null) {
  196.                     if (m_permSet is NamedPermissionSet) {
  197.                         // If the named permission set exists in the parent level of this
  198.                         // policy struct, then just save the name of the permission set.
  199.                         // Otherwise, serialize it like normal.
  200.                        
  201.                         NamedPermissionSet namedPermSet = (NamedPermissionSet)m_permSet;
  202.                         if (level != null && level.GetNamedPermissionSet(namedPermSet.Name) != null) {
  203.                             e.AddAttribute("PermissionSetName", namedPermSet.Name);
  204.                         }
  205.                         else {
  206.                             if (useInternal)
  207.                                 e.AddChild(namedPermSet.InternalToXml());
  208.                             else
  209.                                 e.AddChild(namedPermSet.ToXml());
  210.                         }
  211.                     }
  212.                     else {
  213.                         if (useInternal)
  214.                             e.AddChild(m_permSet.InternalToXml());
  215.                         else
  216.                             e.AddChild(m_permSet.ToXml());
  217.                     }
  218.                 }
  219.             }
  220.            
  221.             return e;
  222.         }
  223.        
  224.         public void FromXml(SecurityElement et, PolicyLevel level)
  225.         {
  226.             FromXml(et, level, false);
  227.         }
  228.        
  229.         internal void FromXml(SecurityElement et, PolicyLevel level, bool allowInternalOnly)
  230.         {
  231.             if (et == null)
  232.                 throw new ArgumentNullException("et");
  233.            
  234.             if (!et.Tag.Equals("PolicyStatement"))
  235.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidXMLElement"), "PolicyStatement", this.GetType().FullName));
  236.            
  237.             m_attributes = (PolicyStatementAttribute)0;
  238.            
  239.             string strAttributes = et.Attribute("Attributes");
  240.            
  241.             if (strAttributes != null)
  242.                 m_attributes = (PolicyStatementAttribute)Enum.Parse(typeof(PolicyStatementAttribute), strAttributes);
  243.            
  244.             lock (this) {
  245.                 m_permSet = null;
  246.                
  247.                 if (level != null) {
  248.                     string permSetName = et.Attribute("PermissionSetName");
  249.                    
  250.                     if (permSetName != null) {
  251.                         m_permSet = level.GetNamedPermissionSetInternal(permSetName);
  252.                        
  253.                         if (m_permSet == null)
  254.                             m_permSet = new PermissionSet(PermissionState.None);
  255.                     }
  256.                 }
  257.                
  258.                
  259.                 if (m_permSet == null) {
  260.                     // There is no provided level, it is not a named permission set, or
  261.                     // the named permission set doesn't exist in the provided level,
  262.                     // so just create the class through reflection and decode normally.
  263.                    
  264.                     SecurityElement e = et.SearchForChildByTag("PermissionSet");
  265.                    
  266.                     if (e != null) {
  267.                         string className = e.Attribute("class");
  268.                        
  269.                         if (className != null && (className.Equals("NamedPermissionSet") || className.Equals("System.Security.NamedPermissionSet")))
  270.                             m_permSet = new NamedPermissionSet("DefaultName", PermissionState.None);
  271.                         else
  272.                             m_permSet = new PermissionSet(PermissionState.None);
  273.                        
  274.                         try {
  275.                             m_permSet.FromXml(e, allowInternalOnly, true);
  276.                         }
  277.                         catch {
  278.                             // ignore any exceptions from the decode process.
  279.                             // Note: we go ahead and use the permission set anyway. This should be safe since
  280.                             // the decode process should never give permission beyond what a proper decode would have
  281.                             // given.
  282.                         }
  283.                     }
  284.                     else {
  285.                         throw new ArgumentException(Environment.GetResourceString("Argument_InvalidXML"));
  286.                     }
  287.                 }
  288.                
  289.                 if (m_permSet == null)
  290.                     m_permSet = new PermissionSet(PermissionState.None);
  291.             }
  292.         }
  293.        
  294.        
  295.         internal void FromXml(SecurityDocument doc, int position, PolicyLevel level, bool allowInternalOnly)
  296.         {
  297.             if (doc == null)
  298.                 throw new ArgumentNullException("doc");
  299.            
  300.             if (!doc.GetTagForElement(position).Equals("PolicyStatement"))
  301.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidXMLElement"), "PolicyStatement", this.GetType().FullName));
  302.            
  303.             m_attributes = (PolicyStatementAttribute)0;
  304.            
  305.             string strAttributes = doc.GetAttributeForElement(position, "Attributes");
  306.            
  307.             if (strAttributes != null)
  308.                 m_attributes = (PolicyStatementAttribute)Enum.Parse(typeof(PolicyStatementAttribute), strAttributes);
  309.            
  310.             lock (this) {
  311.                 m_permSet = null;
  312.                
  313.                 if (level != null) {
  314.                     string permSetName = doc.GetAttributeForElement(position, "PermissionSetName");
  315.                    
  316.                     if (permSetName != null) {
  317.                         m_permSet = level.GetNamedPermissionSetInternal(permSetName);
  318.                        
  319.                         if (m_permSet == null)
  320.                             m_permSet = new PermissionSet(PermissionState.None);
  321.                     }
  322.                 }
  323.                
  324.                
  325.                 if (m_permSet == null) {
  326.                     // There is no provided level, it is not a named permission set, or
  327.                     // the named permission set doesn't exist in the provided level,
  328.                     // so just create the class through reflection and decode normally.
  329.                    
  330.                     ArrayList childPositions = doc.GetChildrenPositionForElement(position);
  331.                     int positionPermissionSet = -1;
  332.                    
  333.                     for (int i = 0; i < childPositions.Count; ++i) {
  334.                         if (doc.GetTagForElement((int)childPositions[i]).Equals("PermissionSet")) {
  335.                             positionPermissionSet = (int)childPositions[i];
  336.                         }
  337.                     }
  338.                    
  339.                     if (positionPermissionSet != -1) {
  340.                         string className = doc.GetAttributeForElement(positionPermissionSet, "class");
  341.                        
  342.                         if (className != null && (className.Equals("NamedPermissionSet") || className.Equals("System.Security.NamedPermissionSet")))
  343.                             m_permSet = new NamedPermissionSet("DefaultName", PermissionState.None);
  344.                         else
  345.                             m_permSet = new PermissionSet(PermissionState.None);
  346.                        
  347.                         m_permSet.FromXml(doc, positionPermissionSet, allowInternalOnly);
  348.                     }
  349.                     else {
  350.                         throw new ArgumentException(Environment.GetResourceString("Argument_InvalidXML"));
  351.                     }
  352.                 }
  353.                
  354.                 if (m_permSet == null)
  355.                     m_permSet = new PermissionSet(PermissionState.None);
  356.             }
  357.         }
  358.        
  359.        
  360.        
  361.         [System.Runtime.InteropServices.ComVisible(false)]
  362.         public override bool Equals(object obj)
  363.         {
  364.             PolicyStatement other = obj as PolicyStatement;
  365.            
  366.             if (other == null)
  367.                 return false;
  368.            
  369.             if (this.m_attributes != other.m_attributes)
  370.                 return false;
  371.            
  372.             if (!Object.Equals(this.m_permSet, other.m_permSet))
  373.                 return false;
  374.            
  375.             return true;
  376.         }
  377.        
  378.         [System.Runtime.InteropServices.ComVisible(false)]
  379.         public override int GetHashCode()
  380.         {
  381.             int accumulator = (int)this.m_attributes;
  382.            
  383.             if (m_permSet != null)
  384.                 accumulator = accumulator ^ m_permSet.GetHashCode();
  385.            
  386.             return accumulator;
  387.         }
  388.        
  389.     }
  390. }

Developer Fusion