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

  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. // EnvironmentPermission.cs
  16. //
  17. namespace System.Security.Permissions
  18. {
  19.     using System.Security;
  20.     using System;
  21.     using SecurityElement = System.Security.SecurityElement;
  22.     using System.Security.Util;
  23.     using System.IO;
  24.     using System.Globalization;
  25.    
  26.     [Flags(), Serializable()]
  27.     [System.Runtime.InteropServices.ComVisible(true)]
  28.     public enum EnvironmentPermissionAccess
  29.     {
  30.         NoAccess = 0,
  31.         Read = 1,
  32.         Write = 2,
  33.         AllAccess = 3
  34.     }
  35.    
  36.     [Serializable()]
  37.     internal class EnvironmentStringExpressionSet : StringExpressionSet
  38.     {
  39.         public EnvironmentStringExpressionSet() : base(true, null, false)
  40.         {
  41.         }
  42.        
  43.         public EnvironmentStringExpressionSet(string str) : base(true, str, false)
  44.         {
  45.         }
  46.        
  47.         protected override StringExpressionSet CreateNewEmpty()
  48.         {
  49.             return new EnvironmentStringExpressionSet();
  50.         }
  51.        
  52.         protected override bool StringSubsetString(string left, string right, bool ignoreCase)
  53.         {
  54.             return (ignoreCase ? (String.Compare(left, right, StringComparison.OrdinalIgnoreCase) == 0) : (String.Compare(left, right, StringComparison.Ordinal) == 0));
  55.         }
  56.        
  57.         protected override string ProcessWholeString(string str)
  58.         {
  59.             return str;
  60.         }
  61.        
  62.         protected override string ProcessSingleString(string str)
  63.         {
  64.             return str;
  65.         }
  66.     }
  67.    
  68.     [System.Runtime.InteropServices.ComVisible(true)]
  69.     [Serializable()]
  70.     public sealed class EnvironmentPermission : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission
  71.     {
  72.         private StringExpressionSet m_read;
  73.         private StringExpressionSet m_write;
  74.         private bool m_unrestricted;
  75.        
  76.         public EnvironmentPermission(PermissionState state)
  77.         {
  78.             if (state == PermissionState.Unrestricted)
  79.                 m_unrestricted = true;
  80.             else if (state == PermissionState.None)
  81.                 m_unrestricted = false;
  82.             else
  83.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
  84.         }
  85.        
  86.         public EnvironmentPermission(EnvironmentPermissionAccess flag, string pathList)
  87.         {
  88.             SetPathList(flag, pathList);
  89.         }
  90.        
  91.         public void SetPathList(EnvironmentPermissionAccess flag, string pathList)
  92.         {
  93.             VerifyFlag(flag);
  94.            
  95.             m_unrestricted = false;
  96.            
  97.             if ((flag & EnvironmentPermissionAccess.Read) != 0)
  98.                 m_read = null;
  99.            
  100.             if ((flag & EnvironmentPermissionAccess.Write) != 0)
  101.                 m_write = null;
  102.            
  103.             AddPathList(flag, pathList);
  104.         }
  105.        
  106.         public void AddPathList(EnvironmentPermissionAccess flag, string pathList)
  107.         {
  108.             VerifyFlag(flag);
  109.            
  110.             if (FlagIsSet(flag, EnvironmentPermissionAccess.Read)) {
  111.                 if (m_read == null)
  112.                     m_read = new EnvironmentStringExpressionSet();
  113.                 m_read.AddExpressions(pathList);
  114.             }
  115.            
  116.             if (FlagIsSet(flag, EnvironmentPermissionAccess.Write)) {
  117.                 if (m_write == null)
  118.                     m_write = new EnvironmentStringExpressionSet();
  119.                 m_write.AddExpressions(pathList);
  120.             }
  121.            
  122.         }
  123.        
  124.         public string GetPathList(EnvironmentPermissionAccess flag)
  125.         {
  126.             VerifyFlag(flag);
  127.             ExclusiveFlag(flag);
  128.            
  129.             if (FlagIsSet(flag, EnvironmentPermissionAccess.Read)) {
  130.                 if (m_read == null) {
  131.                     return "";
  132.                 }
  133.                 return m_read.ToString();
  134.             }
  135.            
  136.             if (FlagIsSet(flag, EnvironmentPermissionAccess.Write)) {
  137.                 if (m_write == null) {
  138.                     return "";
  139.                 }
  140.                 return m_write.ToString();
  141.             }
  142.            
  143.             /* not reached */           
  144.            
  145. return "";
  146.         }
  147.        
  148.        
  149.         private void VerifyFlag(EnvironmentPermissionAccess flag)
  150.         {
  151.             if ((flag & ~EnvironmentPermissionAccess.AllAccess) != 0)
  152.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Arg_EnumIllegalVal"), (int)flag));
  153.         }
  154.        
  155.         private void ExclusiveFlag(EnvironmentPermissionAccess flag)
  156.         {
  157.             if (flag == EnvironmentPermissionAccess.NoAccess) {
  158.                 throw new ArgumentException(Environment.GetResourceString("Arg_EnumNotSingleFlag"));
  159.             }
  160.            
  161.             if (((int)flag & ((int)flag - 1)) != 0) {
  162.                 throw new ArgumentException(Environment.GetResourceString("Arg_EnumNotSingleFlag"));
  163.             }
  164.         }
  165.        
  166.        
  167.         private bool FlagIsSet(EnvironmentPermissionAccess flag, EnvironmentPermissionAccess question)
  168.         {
  169.             return (flag & question) != 0;
  170.         }
  171.        
  172.         private bool IsEmpty()
  173.         {
  174.             return (!m_unrestricted && (this.m_read == null || this.m_read.IsEmpty()) && (this.m_write == null || this.m_write.IsEmpty()));
  175.         }
  176.        
  177.         //------------------------------------------------------
  178.         //
  179.         // CODEACCESSPERMISSION IMPLEMENTATION
  180.         //
  181.         //------------------------------------------------------
  182.        
  183.         public bool IsUnrestricted()
  184.         {
  185.             return m_unrestricted;
  186.         }
  187.        
  188.         //------------------------------------------------------
  189.         //
  190.         // IPERMISSION IMPLEMENTATION
  191.         //
  192.         //------------------------------------------------------
  193.        
  194.         public override bool IsSubsetOf(IPermission target)
  195.         {
  196.             if (target == null) {
  197.                 return this.IsEmpty();
  198.             }
  199.            
  200.             try {
  201.                 EnvironmentPermission operand = (EnvironmentPermission)target;
  202.                 if (operand.IsUnrestricted())
  203.                     return true;
  204.                 else if (this.IsUnrestricted())
  205.                     return false;
  206.                 else
  207.                     return ((this.m_read == null || this.m_read.IsSubsetOf(operand.m_read)) && (this.m_write == null || this.m_write.IsSubsetOf(operand.m_write)));
  208.             }
  209.             catch (InvalidCastException) {
  210.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName));
  211.             }
  212.         }
  213.        
  214.         public override IPermission Intersect(IPermission target)
  215.         {
  216.             if (target == null) {
  217.                 return null;
  218.             }
  219.             else if (!VerifyType(target)) {
  220.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName));
  221.             }
  222.             else if (this.IsUnrestricted()) {
  223.                 return target.Copy();
  224.             }
  225.            
  226.             EnvironmentPermission operand = (EnvironmentPermission)target;
  227.            
  228.             if (operand.IsUnrestricted()) {
  229.                 return this.Copy();
  230.             }
  231.            
  232.             StringExpressionSet intersectRead = this.m_read == null ? null : this.m_read.Intersect(operand.m_read);
  233.             StringExpressionSet intersectWrite = this.m_write == null ? null : this.m_write.Intersect(operand.m_write);
  234.            
  235.             if ((intersectRead == null || intersectRead.IsEmpty()) && (intersectWrite == null || intersectWrite.IsEmpty())) {
  236.                 return null;
  237.             }
  238.            
  239.             EnvironmentPermission intersectPermission = new EnvironmentPermission(PermissionState.None);
  240.             intersectPermission.m_unrestricted = false;
  241.             intersectPermission.m_read = intersectRead;
  242.             intersectPermission.m_write = intersectWrite;
  243.            
  244.             return intersectPermission;
  245.         }
  246.        
  247.         public override IPermission Union(IPermission other)
  248.         {
  249.             if (other == null) {
  250.                 return this.Copy();
  251.             }
  252.             else if (!VerifyType(other)) {
  253.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName));
  254.             }
  255.            
  256.             EnvironmentPermission operand = (EnvironmentPermission)other;
  257.            
  258.             if (this.IsUnrestricted() || operand.IsUnrestricted()) {
  259.                 return new EnvironmentPermission(PermissionState.Unrestricted);
  260.             }
  261.            
  262.             StringExpressionSet unionRead = this.m_read == null ? operand.m_read : this.m_read.Union(operand.m_read);
  263.             StringExpressionSet unionWrite = this.m_write == null ? operand.m_write : this.m_write.Union(operand.m_write);
  264.            
  265.             if ((unionRead == null || unionRead.IsEmpty()) && (unionWrite == null || unionWrite.IsEmpty())) {
  266.                 return null;
  267.             }
  268.            
  269.             EnvironmentPermission unionPermission = new EnvironmentPermission(PermissionState.None);
  270.             unionPermission.m_unrestricted = false;
  271.             unionPermission.m_read = unionRead;
  272.             unionPermission.m_write = unionWrite;
  273.            
  274.             return unionPermission;
  275.         }
  276.        
  277.         public override IPermission Copy()
  278.         {
  279.             EnvironmentPermission copy = new EnvironmentPermission(PermissionState.None);
  280.             if (this.m_unrestricted) {
  281.                 copy.m_unrestricted = true;
  282.             }
  283.             else {
  284.                 copy.m_unrestricted = false;
  285.                 if (this.m_read != null) {
  286.                     copy.m_read = this.m_read.Copy();
  287.                 }
  288.                 if (this.m_write != null) {
  289.                     copy.m_write = this.m_write.Copy();
  290.                 }
  291.                
  292.             }
  293.             return copy;
  294.         }
  295.        
  296.         public override SecurityElement ToXml()
  297.         {
  298.             SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.EnvironmentPermission");
  299.             if (!IsUnrestricted()) {
  300.                 if (this.m_read != null && !this.m_read.IsEmpty()) {
  301.                     esd.AddAttribute("Read", SecurityElement.Escape(m_read.ToString()));
  302.                 }
  303.                 if (this.m_write != null && !this.m_write.IsEmpty()) {
  304.                     esd.AddAttribute("Write", SecurityElement.Escape(m_write.ToString()));
  305.                 }
  306.             }
  307.             else {
  308.                 esd.AddAttribute("Unrestricted", "true");
  309.             }
  310.             return esd;
  311.         }
  312.        
  313.         public override void FromXml(SecurityElement esd)
  314.         {
  315.             CodeAccessPermission.ValidateElement(esd, this);
  316.            
  317.             string et;
  318.            
  319.             if (XMLUtil.IsUnrestricted(esd)) {
  320.                 m_unrestricted = true;
  321.                 return;
  322.             }
  323.            
  324.             m_unrestricted = false;
  325.             m_read = null;
  326.             m_write = null;
  327.            
  328.             et = esd.Attribute("Read");
  329.             if (et != null) {
  330.                 m_read = new EnvironmentStringExpressionSet(et);
  331.             }
  332.            
  333.             et = esd.Attribute("Write");
  334.             if (et != null) {
  335.                 m_write = new EnvironmentStringExpressionSet(et);
  336.             }
  337.            
  338.         }
  339.        
  340.         /// <internalonly/>
  341.         int IBuiltInPermission.GetTokenIndex()
  342.         {
  343.             return EnvironmentPermission.GetTokenIndex();
  344.         }
  345.        
  346.         static internal int GetTokenIndex()
  347.         {
  348.             return BuiltInPermissionIndex.EnvironmentPermissionIndex;
  349.         }
  350.     }
  351.    
  352. }

Developer Fusion