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

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

Developer Fusion