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

  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. // FileIOPermission.cs
  16. //
  17. namespace System.Security.Permissions
  18. {
  19.     using System;
  20.     using System.Runtime.CompilerServices;
  21.     using SecurityElement = System.Security.SecurityElement;
  22.     using System.Security.Util;
  23.     using System.IO;
  24.     using System.Collections;
  25.     using System.Globalization;
  26.     using System.Runtime.Serialization;
  27.    
  28.     [Flags(), Serializable()]
  29.     [System.Runtime.InteropServices.ComVisible(true)]
  30.     public enum FileIOPermissionAccess
  31.     {
  32.         NoAccess = 0,
  33.         Read = 1,
  34.         Write = 2,
  35.         Append = 4,
  36.         PathDiscovery = 8,
  37.         AllAccess = 15
  38.     }
  39.    
  40.    
  41.     [System.Runtime.InteropServices.ComVisible(true)]
  42.     [Serializable()]
  43.     public sealed class FileIOPermission : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission
  44.     {
  45.         private FileIOAccess m_read;
  46.         private FileIOAccess m_write;
  47.         private FileIOAccess m_append;
  48.         private FileIOAccess m_pathDiscovery;
  49.         [OptionalField(VersionAdded = 2)]
  50.         private FileIOAccess m_viewAcl;
  51.         [OptionalField(VersionAdded = 2)]
  52.         private FileIOAccess m_changeAcl;
  53.         private bool m_unrestricted;
  54.        
  55.         private static readonly char[] m_illegalCharacters = {'?', '*'};
  56.        
  57.         public FileIOPermission(PermissionState state)
  58.         {
  59.             if (state == PermissionState.Unrestricted) {
  60.                 m_unrestricted = true;
  61.             }
  62.             else if (state == PermissionState.None) {
  63.                 m_unrestricted = false;
  64.             }
  65.             else {
  66.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
  67.             }
  68.         }
  69.        
  70.         public FileIOPermission(FileIOPermissionAccess access, string path)
  71.         {
  72.             VerifyAccess(access);
  73.            
  74.             string[] pathList = new string[] {path};
  75.             AddPathList(access, pathList, false, true, false);
  76.         }
  77.        
  78.         public FileIOPermission(FileIOPermissionAccess access, string[] pathList)
  79.         {
  80.             VerifyAccess(access);
  81.            
  82.             AddPathList(access, pathList, false, true, false);
  83.         }
  84.        
  85.        
  86.         internal FileIOPermission(FileIOPermissionAccess access, string[] pathList, bool checkForDuplicates, bool needFullPath)
  87.         {
  88.             VerifyAccess(access);
  89.            
  90.             AddPathList(access, pathList, checkForDuplicates, needFullPath, true);
  91.         }
  92.        
  93.        
  94.         public void SetPathList(FileIOPermissionAccess access, string path)
  95.         {
  96.             string[] pathList;
  97.             if (path == null)
  98.                 pathList = new string[] {};
  99.             else
  100.                 pathList = new string[] {path};
  101.             SetPathList(access, pathList, false);
  102.         }
  103.        
  104.         public void SetPathList(FileIOPermissionAccess access, string[] pathList)
  105.         {
  106.             SetPathList(access, pathList, true);
  107.         }
  108.        
  109.         internal void SetPathList(FileIOPermissionAccess access, string[] pathList, bool checkForDuplicates)
  110.         {
  111.             VerifyAccess(access);
  112.            
  113.             if ((access & FileIOPermissionAccess.Read) != 0)
  114.                 m_read = null;
  115.            
  116.             if ((access & FileIOPermissionAccess.Write) != 0)
  117.                 m_write = null;
  118.            
  119.             if ((access & FileIOPermissionAccess.Append) != 0)
  120.                 m_append = null;
  121.            
  122.             if ((access & FileIOPermissionAccess.PathDiscovery) != 0)
  123.                 m_pathDiscovery = null;
  124.            
  125.             m_viewAcl = null;
  126.             m_changeAcl = null;
  127.            
  128.             m_unrestricted = false;
  129.             AddPathList(access, pathList, checkForDuplicates, true, true);
  130.         }
  131.        
  132.         public void AddPathList(FileIOPermissionAccess access, string path)
  133.         {
  134.             string[] pathList;
  135.             if (path == null)
  136.                 pathList = new string[] {};
  137.             else
  138.                 pathList = new string[] {path};
  139.             AddPathList(access, pathList, false, true, false);
  140.         }
  141.        
  142.         public void AddPathList(FileIOPermissionAccess access, string[] pathList)
  143.         {
  144.             AddPathList(access, pathList, true, true, true);
  145.         }
  146.        
  147.         internal void AddPathList(FileIOPermissionAccess access, string[] pathListOrig, bool checkForDuplicates, bool needFullPath, bool copyPathList)
  148.         {
  149.             VerifyAccess(access);
  150.            
  151.             if (pathListOrig == null) {
  152.                 throw new ArgumentNullException("pathList");
  153.             }
  154.             if (pathListOrig.Length == 0) {
  155.                 throw new ArgumentException(Environment.GetResourceString("Argument_EmptyPath"));
  156.             }
  157.            
  158.             if (m_unrestricted)
  159.                 return;
  160.            
  161.             string[] pathList = pathListOrig;
  162.             if (copyPathList) {
  163.                 // Make a copy of pathList (in case its value changes after we check for illegal chars)
  164.                 pathList = new string[pathListOrig.Length];
  165.                 Array.Copy(pathListOrig, pathList, pathListOrig.Length);
  166.             }
  167.            
  168.             HasIllegalCharacters(pathList);
  169.             ArrayList pathArrayList = StringExpressionSet.CreateListFromExpressions(pathList, needFullPath);
  170.            
  171.             if ((access & FileIOPermissionAccess.Read) != 0) {
  172.                 if (m_read == null) {
  173.                     m_read = new FileIOAccess();
  174.                 }
  175.                 m_read.AddExpressions(pathArrayList, checkForDuplicates);
  176.             }
  177.            
  178.             if ((access & FileIOPermissionAccess.Write) != 0) {
  179.                 if (m_write == null) {
  180.                     m_write = new FileIOAccess();
  181.                 }
  182.                 m_write.AddExpressions(pathArrayList, checkForDuplicates);
  183.             }
  184.            
  185.             if ((access & FileIOPermissionAccess.Append) != 0) {
  186.                 if (m_append == null) {
  187.                     m_append = new FileIOAccess();
  188.                 }
  189.                 m_append.AddExpressions(pathArrayList, checkForDuplicates);
  190.             }
  191.            
  192.             if ((access & FileIOPermissionAccess.PathDiscovery) != 0) {
  193.                 if (m_pathDiscovery == null) {
  194.                     m_pathDiscovery = new FileIOAccess(true);
  195.                 }
  196.                 m_pathDiscovery.AddExpressions(pathArrayList, checkForDuplicates);
  197.             }
  198.            
  199.         }
  200.        
  201.         public string[] GetPathList(FileIOPermissionAccess access)
  202.         {
  203.             VerifyAccess(access);
  204.             ExclusiveAccess(access);
  205.            
  206.             if (AccessIsSet(access, FileIOPermissionAccess.Read)) {
  207.                 if (m_read == null) {
  208.                     return null;
  209.                 }
  210.                 return m_read.ToStringArray();
  211.             }
  212.            
  213.             if (AccessIsSet(access, FileIOPermissionAccess.Write)) {
  214.                 if (m_write == null) {
  215.                     return null;
  216.                 }
  217.                 return m_write.ToStringArray();
  218.             }
  219.            
  220.             if (AccessIsSet(access, FileIOPermissionAccess.Append)) {
  221.                 if (m_append == null) {
  222.                     return null;
  223.                 }
  224.                 return m_append.ToStringArray();
  225.             }
  226.            
  227.             if (AccessIsSet(access, FileIOPermissionAccess.PathDiscovery)) {
  228.                 if (m_pathDiscovery == null) {
  229.                     return null;
  230.                 }
  231.                 return m_pathDiscovery.ToStringArray();
  232.             }
  233.            
  234.             // not reached
  235.            
  236.             return null;
  237.         }
  238.        
  239.        
  240.         public FileIOPermissionAccess AllLocalFiles {
  241.             get {
  242.                 if (m_unrestricted)
  243.                     return FileIOPermissionAccess.AllAccess;
  244.                
  245.                 FileIOPermissionAccess access = FileIOPermissionAccess.NoAccess;
  246.                
  247.                 if (m_read != null && m_read.AllLocalFiles) {
  248.                     access |= FileIOPermissionAccess.Read;
  249.                 }
  250.                
  251.                 if (m_write != null && m_write.AllLocalFiles) {
  252.                     access |= FileIOPermissionAccess.Write;
  253.                 }
  254.                
  255.                 if (m_append != null && m_append.AllLocalFiles) {
  256.                     access |= FileIOPermissionAccess.Append;
  257.                 }
  258.                
  259.                 if (m_pathDiscovery != null && m_pathDiscovery.AllLocalFiles) {
  260.                     access |= FileIOPermissionAccess.PathDiscovery;
  261.                 }
  262.                
  263.                 return access;
  264.             }
  265.            
  266.             set {
  267.                 if ((value & FileIOPermissionAccess.Read) != 0) {
  268.                     if (m_read == null)
  269.                         m_read = new FileIOAccess();
  270.                    
  271.                     m_read.AllLocalFiles = true;
  272.                 }
  273.                 else {
  274.                     if (m_read != null)
  275.                         m_read.AllLocalFiles = false;
  276.                 }
  277.                
  278.                 if ((value & FileIOPermissionAccess.Write) != 0) {
  279.                     if (m_write == null)
  280.                         m_write = new FileIOAccess();
  281.                    
  282.                     m_write.AllLocalFiles = true;
  283.                 }
  284.                 else {
  285.                     if (m_write != null)
  286.                         m_write.AllLocalFiles = false;
  287.                 }
  288.                
  289.                 if ((value & FileIOPermissionAccess.Append) != 0) {
  290.                     if (m_append == null)
  291.                         m_append = new FileIOAccess();
  292.                    
  293.                     m_append.AllLocalFiles = true;
  294.                 }
  295.                 else {
  296.                     if (m_append != null)
  297.                         m_append.AllLocalFiles = false;
  298.                 }
  299.                
  300.                 if ((value & FileIOPermissionAccess.PathDiscovery) != 0) {
  301.                     if (m_pathDiscovery == null)
  302.                         m_pathDiscovery = new FileIOAccess(true);
  303.                    
  304.                     m_pathDiscovery.AllLocalFiles = true;
  305.                 }
  306.                 else {
  307.                     if (m_pathDiscovery != null)
  308.                         m_pathDiscovery.AllLocalFiles = false;
  309.                 }
  310.                
  311.             }
  312.         }
  313.        
  314.         public FileIOPermissionAccess AllFiles {
  315.             get {
  316.                 if (m_unrestricted)
  317.                     return FileIOPermissionAccess.AllAccess;
  318.                
  319.                 FileIOPermissionAccess access = FileIOPermissionAccess.NoAccess;
  320.                
  321.                 if (m_read != null && m_read.AllFiles) {
  322.                     access |= FileIOPermissionAccess.Read;
  323.                 }
  324.                
  325.                 if (m_write != null && m_write.AllFiles) {
  326.                     access |= FileIOPermissionAccess.Write;
  327.                 }
  328.                
  329.                 if (m_append != null && m_append.AllFiles) {
  330.                     access |= FileIOPermissionAccess.Append;
  331.                 }
  332.                
  333.                 if (m_pathDiscovery != null && m_pathDiscovery.AllFiles) {
  334.                     access |= FileIOPermissionAccess.PathDiscovery;
  335.                 }
  336.                
  337.                 return access;
  338.             }
  339.            
  340.             set {
  341.                 if (value == FileIOPermissionAccess.AllAccess) {
  342.                     m_unrestricted = true;
  343.                     return;
  344.                 }
  345.                
  346.                 if ((value & FileIOPermissionAccess.Read) != 0) {
  347.                     if (m_read == null)
  348.                         m_read = new FileIOAccess();
  349.                    
  350.                     m_read.AllFiles = true;
  351.                 }
  352.                 else {
  353.                     if (m_read != null)
  354.                         m_read.AllFiles = false;
  355.                 }
  356.                
  357.                 if ((value & FileIOPermissionAccess.Write) != 0) {
  358.                     if (m_write == null)
  359.                         m_write = new FileIOAccess();
  360.                    
  361.                     m_write.AllFiles = true;
  362.                 }
  363.                 else {
  364.                     if (m_write != null)
  365.                         m_write.AllFiles = false;
  366.                 }
  367.                
  368.                 if ((value & FileIOPermissionAccess.Append) != 0) {
  369.                     if (m_append == null)
  370.                         m_append = new FileIOAccess();
  371.                    
  372.                     m_append.AllFiles = true;
  373.                 }
  374.                 else {
  375.                     if (m_append != null)
  376.                         m_append.AllFiles = false;
  377.                 }
  378.                
  379.                 if ((value & FileIOPermissionAccess.PathDiscovery) != 0) {
  380.                     if (m_pathDiscovery == null)
  381.                         m_pathDiscovery = new FileIOAccess(true);
  382.                    
  383.                     m_pathDiscovery.AllFiles = true;
  384.                 }
  385.                 else {
  386.                     if (m_pathDiscovery != null)
  387.                         m_pathDiscovery.AllFiles = false;
  388.                 }
  389.                
  390.             }
  391.         }
  392.        
  393.         private void VerifyAccess(FileIOPermissionAccess access)
  394.         {
  395.             if ((access & ~FileIOPermissionAccess.AllAccess) != 0)
  396.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Arg_EnumIllegalVal"), (int)access));
  397.         }
  398.        
  399.         private void ExclusiveAccess(FileIOPermissionAccess access)
  400.         {
  401.             if (access == FileIOPermissionAccess.NoAccess) {
  402.                 throw new ArgumentException(Environment.GetResourceString("Arg_EnumNotSingleFlag"));
  403.             }
  404.            
  405.             if (((int)access & ((int)access - 1)) != 0) {
  406.                 throw new ArgumentException(Environment.GetResourceString("Arg_EnumNotSingleFlag"));
  407.             }
  408.         }
  409.        
  410.         private static void HasIllegalCharacters(string[] str)
  411.         {
  412.             for (int i = 0; i < str.Length; ++i) {
  413.                 if (str[i] == null)
  414.                     throw new ArgumentNullException("str");
  415.                
  416.                 Path.CheckInvalidPathChars(str[i]);
  417.                
  418.                 if (str[i].IndexOfAny(m_illegalCharacters) != -1)
  419.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPathChars"));
  420.             }
  421.         }
  422.        
  423.         private bool AccessIsSet(FileIOPermissionAccess access, FileIOPermissionAccess question)
  424.         {
  425.             return (access & question) != 0;
  426.         }
  427.        
  428.         private bool IsEmpty()
  429.         {
  430.             return (!m_unrestricted && (this.m_read == null || this.m_read.IsEmpty()) && (this.m_write == null || this.m_write.IsEmpty()) && (this.m_append == null || this.m_append.IsEmpty()) && (this.m_pathDiscovery == null || this.m_pathDiscovery.IsEmpty()) && (this.m_viewAcl == null || this.m_viewAcl.IsEmpty()) && (this.m_changeAcl == null || this.m_changeAcl.IsEmpty()));
  431.         }
  432.        
  433.         //------------------------------------------------------
  434.         //
  435.         // CODEACCESSPERMISSION IMPLEMENTATION
  436.         //
  437.         //------------------------------------------------------
  438.        
  439.         public bool IsUnrestricted()
  440.         {
  441.             return m_unrestricted;
  442.         }
  443.        
  444.         //------------------------------------------------------
  445.         //
  446.         // IPERMISSION IMPLEMENTATION
  447.         //
  448.         //------------------------------------------------------
  449.        
  450.         public override bool IsSubsetOf(IPermission target)
  451.         {
  452.             if (target == null) {
  453.                 return this.IsEmpty();
  454.             }
  455.            
  456.             FileIOPermission operand = target as FileIOPermission;
  457.             if (operand == null)
  458.                 throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
  459.            
  460.             if (operand.IsUnrestricted())
  461.                 return true;
  462.             else if (this.IsUnrestricted())
  463.                 return false;
  464.             else
  465.                 return ((this.m_read == null || this.m_read.IsSubsetOf(operand.m_read)) && (this.m_write == null || this.m_write.IsSubsetOf(operand.m_write)) && (this.m_append == null || this.m_append.IsSubsetOf(operand.m_append)) && (this.m_pathDiscovery == null || this.m_pathDiscovery.IsSubsetOf(operand.m_pathDiscovery)) && (this.m_viewAcl == null || this.m_viewAcl.IsSubsetOf(operand.m_viewAcl)) && (this.m_changeAcl == null || this.m_changeAcl.IsSubsetOf(operand.m_changeAcl)));
  466.         }
  467.        
  468.         public override IPermission Intersect(IPermission target)
  469.         {
  470.             if (target == null) {
  471.                 return null;
  472.             }
  473.            
  474.             FileIOPermission operand = target as FileIOPermission;
  475.            
  476.             if (operand == null) {
  477.                 throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
  478.             }
  479.             else if (this.IsUnrestricted()) {
  480.                 return target.Copy();
  481.             }
  482.            
  483.             if (operand.IsUnrestricted()) {
  484.                 return this.Copy();
  485.             }
  486.            
  487.             FileIOAccess intersectRead = this.m_read == null ? null : this.m_read.Intersect(operand.m_read);
  488.             FileIOAccess intersectWrite = this.m_write == null ? null : this.m_write.Intersect(operand.m_write);
  489.             FileIOAccess intersectAppend = this.m_append == null ? null : this.m_append.Intersect(operand.m_append);
  490.             FileIOAccess intersectPathDiscovery = this.m_pathDiscovery == null ? null : this.m_pathDiscovery.Intersect(operand.m_pathDiscovery);
  491.             FileIOAccess intersectViewAcl = this.m_viewAcl == null ? null : this.m_viewAcl.Intersect(operand.m_viewAcl);
  492.             FileIOAccess intersectChangeAcl = this.m_changeAcl == null ? null : this.m_changeAcl.Intersect(operand.m_changeAcl);
  493.            
  494.             if ((intersectRead == null || intersectRead.IsEmpty()) && (intersectWrite == null || intersectWrite.IsEmpty()) && (intersectAppend == null || intersectAppend.IsEmpty()) && (intersectPathDiscovery == null || intersectPathDiscovery.IsEmpty()) && (intersectViewAcl == null || intersectViewAcl.IsEmpty()) && (intersectChangeAcl == null || intersectChangeAcl.IsEmpty())) {
  495.                 return null;
  496.             }
  497.            
  498.             FileIOPermission intersectPermission = new FileIOPermission(PermissionState.None);
  499.             intersectPermission.m_unrestricted = false;
  500.             intersectPermission.m_read = intersectRead;
  501.             intersectPermission.m_write = intersectWrite;
  502.             intersectPermission.m_append = intersectAppend;
  503.             intersectPermission.m_pathDiscovery = intersectPathDiscovery;
  504.             intersectPermission.m_viewAcl = intersectViewAcl;
  505.             intersectPermission.m_changeAcl = intersectChangeAcl;
  506.            
  507.             return intersectPermission;
  508.         }
  509.        
  510.         public override IPermission Union(IPermission other)
  511.         {
  512.             if (other == null) {
  513.                 return this.Copy();
  514.             }
  515.            
  516.             FileIOPermission operand = other as FileIOPermission;
  517.            
  518.             if (operand == null) {
  519.                 throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", this.GetType().FullName));
  520.             }
  521.            
  522.             if (this.IsUnrestricted() || operand.IsUnrestricted()) {
  523.                 return new FileIOPermission(PermissionState.Unrestricted);
  524.             }
  525.            
  526.             FileIOAccess unionRead = this.m_read == null ? operand.m_read : this.m_read.Union(operand.m_read);
  527.             FileIOAccess unionWrite = this.m_write == null ? operand.m_write : this.m_write.Union(operand.m_write);
  528.             FileIOAccess unionAppend = this.m_append == null ? operand.m_append : this.m_append.Union(operand.m_append);
  529.             FileIOAccess unionPathDiscovery = this.m_pathDiscovery == null ? operand.m_pathDiscovery : this.m_pathDiscovery.Union(operand.m_pathDiscovery);
  530.             FileIOAccess unionViewAcl = this.m_viewAcl == null ? operand.m_viewAcl : this.m_viewAcl.Union(operand.m_viewAcl);
  531.             FileIOAccess unionChangeAcl = this.m_changeAcl == null ? operand.m_changeAcl : this.m_changeAcl.Union(operand.m_changeAcl);
  532.            
  533.             if ((unionRead == null || unionRead.IsEmpty()) && (unionWrite == null || unionWrite.IsEmpty()) && (unionAppend == null || unionAppend.IsEmpty()) && (unionPathDiscovery == null || unionPathDiscovery.IsEmpty()) && (unionViewAcl == null || unionViewAcl.IsEmpty()) && (unionChangeAcl == null || unionChangeAcl.IsEmpty())) {
  534.                 return null;
  535.             }
  536.            
  537.             FileIOPermission unionPermission = new FileIOPermission(PermissionState.None);
  538.             unionPermission.m_unrestricted = false;
  539.             unionPermission.m_read = unionRead;
  540.             unionPermission.m_write = unionWrite;
  541.             unionPermission.m_append = unionAppend;
  542.             unionPermission.m_pathDiscovery = unionPathDiscovery;
  543.             unionPermission.m_viewAcl = unionViewAcl;
  544.             unionPermission.m_changeAcl = unionChangeAcl;
  545.            
  546.             return unionPermission;
  547.         }
  548.        
  549.         public override IPermission Copy()
  550.         {
  551.             FileIOPermission copy = new FileIOPermission(PermissionState.None);
  552.             if (this.m_unrestricted) {
  553.                 copy.m_unrestricted = true;
  554.             }
  555.             else {
  556.                 copy.m_unrestricted = false;
  557.                 if (this.m_read != null) {
  558.                     copy.m_read = this.m_read.Copy();
  559.                 }
  560.                 if (this.m_write != null) {
  561.                     copy.m_write = this.m_write.Copy();
  562.                 }
  563.                 if (this.m_append != null) {
  564.                     copy.m_append = this.m_append.Copy();
  565.                 }
  566.                 if (this.m_pathDiscovery != null) {
  567.                     copy.m_pathDiscovery = this.m_pathDiscovery.Copy();
  568.                 }
  569.                 if (this.m_viewAcl != null) {
  570.                     copy.m_viewAcl = this.m_viewAcl.Copy();
  571.                 }
  572.                 if (this.m_changeAcl != null) {
  573.                     copy.m_changeAcl = this.m_changeAcl.Copy();
  574.                 }
  575.             }
  576.             return copy;
  577.         }
  578.        
  579.         public override SecurityElement ToXml()
  580.         {
  581.             SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.FileIOPermission");
  582.             if (!IsUnrestricted()) {
  583.                 if (this.m_read != null && !this.m_read.IsEmpty()) {
  584.                     esd.AddAttribute("Read", SecurityElement.Escape(m_read.ToString()));
  585.                 }
  586.                 if (this.m_write != null && !this.m_write.IsEmpty()) {
  587.                     esd.AddAttribute("Write", SecurityElement.Escape(m_write.ToString()));
  588.                 }
  589.                 if (this.m_append != null && !this.m_append.IsEmpty()) {
  590.                     esd.AddAttribute("Append", SecurityElement.Escape(m_append.ToString()));
  591.                 }
  592.                 if (this.m_pathDiscovery != null && !this.m_pathDiscovery.IsEmpty()) {
  593.                     esd.AddAttribute("PathDiscovery", SecurityElement.Escape(m_pathDiscovery.ToString()));
  594.                 }
  595.                 if (this.m_viewAcl != null && !this.m_viewAcl.IsEmpty()) {
  596.                     esd.AddAttribute("ViewAcl", SecurityElement.Escape(m_viewAcl.ToString()));
  597.                 }
  598.                 if (this.m_changeAcl != null && !this.m_changeAcl.IsEmpty()) {
  599.                     esd.AddAttribute("ChangeAcl", SecurityElement.Escape(m_changeAcl.ToString()));
  600.                 }
  601.                
  602.             }
  603.             else {
  604.                 esd.AddAttribute("Unrestricted", "true");
  605.             }
  606.             return esd;
  607.         }
  608.        
  609.         public override void FromXml(SecurityElement esd)
  610.         {
  611.             CodeAccessPermission.ValidateElement(esd, this);
  612.             string et;
  613.            
  614.             if (XMLUtil.IsUnrestricted(esd)) {
  615.                 m_unrestricted = true;
  616.                 return;
  617.             }
  618.            
  619.            
  620.             m_unrestricted = false;
  621.            
  622.             et = esd.Attribute("Read");
  623.             if (et != null) {
  624.                 m_read = new FileIOAccess(et);
  625.             }
  626.             else {
  627.                 m_read = null;
  628.             }
  629.            
  630.             et = esd.Attribute("Write");
  631.             if (et != null) {
  632.                 m_write = new FileIOAccess(et);
  633.             }
  634.             else {
  635.                 m_write = null;
  636.             }
  637.            
  638.             et = esd.Attribute("Append");
  639.             if (et != null) {
  640.                 m_append = new FileIOAccess(et);
  641.             }
  642.             else {
  643.                 m_append = null;
  644.             }
  645.            
  646.             et = esd.Attribute("PathDiscovery");
  647.             if (et != null) {
  648.                 m_pathDiscovery = new FileIOAccess(et);
  649.                 m_pathDiscovery.PathDiscovery = true;
  650.             }
  651.             else {
  652.                 m_pathDiscovery = null;
  653.             }
  654.            
  655.             et = esd.Attribute("ViewAcl");
  656.             if (et != null) {
  657.                 m_viewAcl = new FileIOAccess(et);
  658.             }
  659.             else {
  660.                 m_viewAcl = null;
  661.             }
  662.            
  663.             et = esd.Attribute("ChangeAcl");
  664.             if (et != null) {
  665.                 m_changeAcl = new FileIOAccess(et);
  666.             }
  667.             else {
  668.                 m_changeAcl = null;
  669.             }
  670.         }
  671.        
  672.         /// <internalonly/>
  673.         int IBuiltInPermission.GetTokenIndex()
  674.         {
  675.             return FileIOPermission.GetTokenIndex();
  676.         }
  677.        
  678.         static internal int GetTokenIndex()
  679.         {
  680.             return BuiltInPermissionIndex.FileIOPermissionIndex;
  681.         }
  682.        
  683.         [System.Runtime.InteropServices.ComVisible(false)]
  684.         public override bool Equals(object obj)
  685.         {
  686.             FileIOPermission perm = obj as FileIOPermission;
  687.             if (perm == null)
  688.                 return false;
  689.            
  690.             if (m_unrestricted && perm.m_unrestricted)
  691.                 return true;
  692.             if (m_unrestricted != perm.m_unrestricted)
  693.                 return false;
  694.            
  695.             if (m_read == null) {
  696.                 if (perm.m_read != null && !perm.m_read.IsEmpty())
  697.                     return false;
  698.             }
  699.             else if (!m_read.Equals(perm.m_read))
  700.                 return false;
  701.            
  702.             if (m_write == null) {
  703.                 if (perm.m_write != null && !perm.m_write.IsEmpty())
  704.                     return false;
  705.             }
  706.             else if (!m_write.Equals(perm.m_write))
  707.                 return false;
  708.            
  709.             if (m_append == null) {
  710.                 if (perm.m_append != null && !perm.m_append.IsEmpty())
  711.                     return false;
  712.             }
  713.             else if (!m_append.Equals(perm.m_append))
  714.                 return false;
  715.            
  716.             if (m_pathDiscovery == null) {
  717.                 if (perm.m_pathDiscovery != null && !perm.m_pathDiscovery.IsEmpty())
  718.                     return false;
  719.             }
  720.             else if (!m_pathDiscovery.Equals(perm.m_pathDiscovery))
  721.                 return false;
  722.            
  723.             if (m_viewAcl == null) {
  724.                 if (perm.m_viewAcl != null && !perm.m_viewAcl.IsEmpty())
  725.                     return false;
  726.             }
  727.             else if (!m_viewAcl.Equals(perm.m_viewAcl))
  728.                 return false;
  729.            
  730.             if (m_changeAcl == null) {
  731.                 if (perm.m_changeAcl != null && !perm.m_changeAcl.IsEmpty())
  732.                     return false;
  733.             }
  734.             else if (!m_changeAcl.Equals(perm.m_changeAcl))
  735.                 return false;
  736.            
  737.             return true;
  738.         }
  739.        
  740.         [System.Runtime.InteropServices.ComVisible(false)]
  741.         public override int GetHashCode()
  742.         {
  743.             // This implementation is only to silence a compiler warning.
  744.             return base.GetHashCode();
  745.         }
  746.     }
  747.    
  748.     [Serializable()]
  749.     internal sealed class FileIOAccess
  750.     {
  751.         #if !FEATURE_CASE_SENSITIVE_FILESYSTEM
  752.         private bool m_ignoreCase = true;
  753.         #else
  754.         private bool m_ignoreCase = false;
  755.         #endif // !FEATURE_CASE_SENSITIVE_FILESYSTEM
  756.        
  757.         private StringExpressionSet m_set;
  758.         private bool m_allFiles;
  759.         private bool m_allLocalFiles;
  760.         private bool m_pathDiscovery;
  761.        
  762.         private const string m_strAllFiles = "*AllFiles*";
  763.         private const string m_strAllLocalFiles = "*AllLocalFiles*";
  764.        
  765.         public FileIOAccess()
  766.         {
  767.             m_set = new StringExpressionSet(m_ignoreCase, true);
  768.             m_allFiles = false;
  769.             m_allLocalFiles = false;
  770.             m_pathDiscovery = false;
  771.         }
  772.        
  773.         public FileIOAccess(bool pathDiscovery)
  774.         {
  775.             m_set = new StringExpressionSet(m_ignoreCase, true);
  776.             m_allFiles = false;
  777.             m_allLocalFiles = false;
  778.             m_pathDiscovery = pathDiscovery;
  779.         }
  780.        
  781.         public FileIOAccess(string value)
  782.         {
  783.             if (value == null) {
  784.                 m_set = new StringExpressionSet(m_ignoreCase, true);
  785.                 m_allFiles = false;
  786.                 m_allLocalFiles = false;
  787.             }
  788.             else if (value.Length >= m_strAllFiles.Length && String.Compare(m_strAllFiles, value, StringComparison.Ordinal) == 0) {
  789.                 m_set = new StringExpressionSet(m_ignoreCase, true);
  790.                 m_allFiles = true;
  791.                 m_allLocalFiles = false;
  792.             }
  793.             else if (value.Length >= m_strAllLocalFiles.Length && String.Compare(m_strAllLocalFiles, 0, value, 0, m_strAllLocalFiles.Length, StringComparison.Ordinal) == 0) {
  794.                 m_set = new StringExpressionSet(m_ignoreCase, value.Substring(m_strAllLocalFiles.Length), true);
  795.                 m_allFiles = false;
  796.                 m_allLocalFiles = true;
  797.             }
  798.             else {
  799.                 m_set = new StringExpressionSet(m_ignoreCase, value, true);
  800.                 m_allFiles = false;
  801.                 m_allLocalFiles = false;
  802.             }
  803.             m_pathDiscovery = false;
  804.         }
  805.        
  806.         public FileIOAccess(bool allFiles, bool allLocalFiles, bool pathDiscovery)
  807.         {
  808.             m_set = new StringExpressionSet(m_ignoreCase, true);
  809.             m_allFiles = allFiles;
  810.             m_allLocalFiles = allLocalFiles;
  811.             m_pathDiscovery = pathDiscovery;
  812.         }
  813.        
  814.         public FileIOAccess(StringExpressionSet set, bool allFiles, bool allLocalFiles, bool pathDiscovery)
  815.         {
  816.             m_set = set;
  817.             m_set.SetThrowOnRelative(true);
  818.             m_allFiles = allFiles;
  819.             m_allLocalFiles = allLocalFiles;
  820.             m_pathDiscovery = pathDiscovery;
  821.         }
  822.        
  823.         private FileIOAccess(FileIOAccess operand)
  824.         {
  825.             m_set = operand.m_set.Copy();
  826.             m_allFiles = operand.m_allFiles;
  827.             m_allLocalFiles = operand.m_allLocalFiles;
  828.             m_pathDiscovery = operand.m_pathDiscovery;
  829.         }
  830.        
  831.         public void AddExpressions(ArrayList values, bool checkForDuplicates)
  832.         {
  833.             m_allFiles = false;
  834.             m_set.AddExpressions(values, checkForDuplicates);
  835.         }
  836.        
  837.        
  838.         public bool AllFiles {
  839.             get { return m_allFiles; }
  840.            
  841.             set { m_allFiles = value; }
  842.         }
  843.        
  844.         public bool AllLocalFiles {
  845.             get { return m_allLocalFiles; }
  846.            
  847.             set { m_allLocalFiles = value; }
  848.         }
  849.        
  850.         public bool PathDiscovery {
  851.             set { m_pathDiscovery = value; }
  852.         }
  853.        
  854.         public bool IsEmpty()
  855.         {
  856.             return !m_allFiles && !m_allLocalFiles && (m_set == null || m_set.IsEmpty());
  857.         }
  858.        
  859.         public FileIOAccess Copy()
  860.         {
  861.             return new FileIOAccess(this);
  862.         }
  863.        
  864.         public FileIOAccess Union(FileIOAccess operand)
  865.         {
  866.             if (operand == null) {
  867.                 return this.IsEmpty() ? null : this.Copy();
  868.             }
  869.            
  870.             BCLDebug.Assert(this.m_pathDiscovery == operand.m_pathDiscovery, "Path discovery settings must match");
  871.            
  872.             if (this.m_allFiles || operand.m_allFiles) {
  873.                 return new FileIOAccess(true, false, this.m_pathDiscovery);
  874.             }
  875.            
  876.             return new FileIOAccess(this.m_set.Union(operand.m_set), false, this.m_allLocalFiles || operand.m_allLocalFiles, this.m_pathDiscovery);
  877.         }
  878.        
  879.         public FileIOAccess Intersect(FileIOAccess operand)
  880.         {
  881.             if (operand == null) {
  882.                 return null;
  883.             }
  884.            
  885.             BCLDebug.Assert(this.m_pathDiscovery == operand.m_pathDiscovery, "Path discovery settings must match");
  886.            
  887.             if (this.m_allFiles) {
  888.                 if (operand.m_allFiles) {
  889.                     return new FileIOAccess(true, false, this.m_pathDiscovery);
  890.                 }
  891.                 else {
  892.                     return new FileIOAccess(operand.m_set.Copy(), false, operand.m_allLocalFiles, this.m_pathDiscovery);
  893.                 }
  894.             }
  895.             else if (operand.m_allFiles) {
  896.                 return new FileIOAccess(this.m_set.Copy(), false, this.m_allLocalFiles, this.m_pathDiscovery);
  897.             }
  898.            
  899.             StringExpressionSet intersectionSet = new StringExpressionSet(m_ignoreCase, true);
  900.            
  901.             if (this.m_allLocalFiles) {
  902.                 string[] expressions = operand.m_set.ToStringArray();
  903.                
  904.                 if (expressions != null) {
  905.                     for (int i = 0; i < expressions.Length; ++i) {
  906.                         string root = GetRoot(expressions[i]);
  907.                         if (root != null && _LocalDrive(GetRoot(root))) {
  908.                             intersectionSet.AddExpressions(new string[] {expressions[i]}, true, false);
  909.                         }
  910.                     }
  911.                 }
  912.             }
  913.            
  914.             if (operand.m_allLocalFiles) {
  915.                 string[] expressions = this.m_set.ToStringArray();
  916.                
  917.                 if (expressions != null) {
  918.                     for (int i = 0; i < expressions.Length; ++i) {
  919.                         string root = GetRoot(expressions[i]);
  920.                         if (root != null && _LocalDrive(GetRoot(root))) {
  921.                             intersectionSet.AddExpressions(new string[] {expressions[i]}, true, false);
  922.                         }
  923.                     }
  924.                 }
  925.             }
  926.            
  927.             string[] regularIntersection = this.m_set.Intersect(operand.m_set).ToStringArray();
  928.            
  929.             if (regularIntersection != null)
  930.                 intersectionSet.AddExpressions(regularIntersection, !intersectionSet.IsEmpty(), false);
  931.            
  932.             return new FileIOAccess(intersectionSet, false, this.m_allLocalFiles && operand.m_allLocalFiles, this.m_pathDiscovery);
  933.         }
  934.        
  935.         public bool IsSubsetOf(FileIOAccess operand)
  936.         {
  937.             if (operand == null) {
  938.                 return this.IsEmpty();
  939.             }
  940.            
  941.             if (operand.m_allFiles) {
  942.                 return true;
  943.             }
  944.            
  945.             BCLDebug.Assert(this.m_pathDiscovery == operand.m_pathDiscovery, "Path discovery settings must match");
  946.            
  947.             if (!((m_pathDiscovery && this.m_set.IsSubsetOfPathDiscovery(operand.m_set)) || this.m_set.IsSubsetOf(operand.m_set))) {
  948.                 if (operand.m_allLocalFiles) {
  949.                     string[] expressions = m_set.ToStringArray();
  950.                    
  951.                     for (int i = 0; i < expressions.Length; ++i) {
  952.                         string root = GetRoot(expressions[i]);
  953.                         if (root == null || !_LocalDrive(GetRoot(root))) {
  954.                             return false;
  955.                         }
  956.                     }
  957.                 }
  958.                 else {
  959.                     return false;
  960.                 }
  961.             }
  962.            
  963.             return true;
  964.         }
  965.        
  966.         private static string GetRoot(string path)
  967.         {
  968.             #if !PLATFORM_UNIX
  969.             string str = path.Substring(0, 3);
  970.             if (str.EndsWith(":\\", StringComparison.Ordinal))
  971.                 #else
  972.                 String;
  973.             str = path.Substring(0, 1);
  974.             #endif // !PLATFORM_UNIX
  975.             if (str == "/") {
  976.                 return str;
  977.             }
  978.             else {
  979.                 return null;
  980.             }
  981.         }
  982.        
  983.         public override string ToString()
  984.         {
  985.             if (m_allFiles) {
  986.                 return m_strAllFiles;
  987.             }
  988.             else {
  989.                 if (m_allLocalFiles) {
  990.                     string retstr = m_strAllLocalFiles;
  991.                    
  992.                     string tempStr = m_set.ToString();
  993.                    
  994.                     if (tempStr != null && tempStr.Length > 0)
  995.                         retstr += ";" + tempStr;
  996.                    
  997.                     return retstr;
  998.                 }
  999.                 else {
  1000.                     return m_set.ToString();
  1001.                 }
  1002.             }
  1003.         }
  1004.        
  1005.         public string[] ToStringArray()
  1006.         {
  1007.             return m_set.ToStringArray();
  1008.         }
  1009.        
  1010.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  1011.         static internal extern bool _LocalDrive(string path);
  1012.        
  1013.         public override bool Equals(object obj)
  1014.         {
  1015.             FileIOAccess operand = obj as FileIOAccess;
  1016.             if (operand == null)
  1017.                 return (IsEmpty() && obj == null);
  1018.             BCLDebug.Assert(this.m_pathDiscovery == operand.m_pathDiscovery, "Path discovery settings must match");
  1019.             if (m_pathDiscovery) {
  1020.                 if (this.m_allFiles && operand.m_allFiles)
  1021.                     return true;
  1022.                 if (this.m_allLocalFiles == operand.m_allLocalFiles && m_set.IsSubsetOf(operand.m_set) && operand.m_set.IsSubsetOf(m_set))
  1023.                     // Watch Out: This calls StringExpressionSet.IsSubsetOf, unlike below
  1024.                     return true;
  1025.                 return false;
  1026.             }
  1027.             else {
  1028.                 if (!this.IsSubsetOf(operand))
  1029.                     // Watch Out: This calls FileIOAccess.IsSubsetOf, unlike above
  1030.                     return false;
  1031.                 if (!operand.IsSubsetOf(this))
  1032.                     return false;
  1033.                 return true;
  1034.             }
  1035.         }
  1036.        
  1037.         public override int GetHashCode()
  1038.         {
  1039.             // This implementation is only to silence a compiler warning.
  1040.             return base.GetHashCode();
  1041.         }
  1042.     }
  1043. }

Developer Fusion