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

  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. // FileDialogPermission.cs
  16. //
  17. namespace System.Security.Permissions
  18. {
  19.     using System;
  20.     using System.Text;
  21.     using System.Security;
  22.     using System.Security.Util;
  23.     using System.IO;
  24.     using System.Runtime.Serialization;
  25.     using System.Reflection;
  26.     using System.Collections;
  27.     using System.Globalization;
  28.    
  29.     [Serializable(), Flags()]
  30.     [System.Runtime.InteropServices.ComVisible(true)]
  31.     public enum FileDialogPermissionAccess
  32.     {
  33.         None = 0,
  34.        
  35.         Open = 1,
  36.        
  37.         Save = 2,
  38.        
  39.         OpenSave = Open | Save
  40.        
  41.     }
  42.    
  43.     [Serializable()]
  44.     [System.Runtime.InteropServices.ComVisible(true)]
  45.     public sealed class FileDialogPermission : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission
  46.     {
  47.         FileDialogPermissionAccess access;
  48.        
  49.         public FileDialogPermission(PermissionState state)
  50.         {
  51.             if (state == PermissionState.Unrestricted) {
  52.                 SetUnrestricted(true);
  53.             }
  54.             else if (state == PermissionState.None) {
  55.                 SetUnrestricted(false);
  56.                 Reset();
  57.             }
  58.             else {
  59.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
  60.             }
  61.         }
  62.        
  63.         public FileDialogPermission(FileDialogPermissionAccess access)
  64.         {
  65.             VerifyAccess(access);
  66.             this.access = access;
  67.         }
  68.        
  69.         public FileDialogPermissionAccess Access {
  70.             get { return access; }
  71.            
  72.             set {
  73.                 VerifyAccess(value);
  74.                 access = value;
  75.             }
  76.         }
  77.        
  78.         public override IPermission Copy()
  79.         {
  80.             return new FileDialogPermission(this.access);
  81.         }
  82.        
  83.         public override void FromXml(SecurityElement esd)
  84.         {
  85.             CodeAccessPermission.ValidateElement(esd, this);
  86.             if (XMLUtil.IsUnrestricted(esd)) {
  87.                 SetUnrestricted(true);
  88.                 return;
  89.             }
  90.            
  91.             access = FileDialogPermissionAccess.None;
  92.            
  93.             string accessXml = esd.Attribute("Access");
  94.             if (accessXml != null)
  95.                 access = (FileDialogPermissionAccess)Enum.Parse(typeof(FileDialogPermissionAccess), accessXml);
  96.         }
  97.        
  98.         /// <internalonly/>
  99.         int IBuiltInPermission.GetTokenIndex()
  100.         {
  101.             return FileDialogPermission.GetTokenIndex();
  102.         }
  103.        
  104.         static internal int GetTokenIndex()
  105.         {
  106.             return BuiltInPermissionIndex.FileDialogPermissionIndex;
  107.         }
  108.        
  109.         public override IPermission Intersect(IPermission target)
  110.         {
  111.             if (target == null) {
  112.                 return null;
  113.             }
  114.             else if (!VerifyType(target)) {
  115.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName));
  116.             }
  117.            
  118.             FileDialogPermission operand = (FileDialogPermission)target;
  119.            
  120.             FileDialogPermissionAccess intersectAccess = access & operand.Access;
  121.            
  122.             if (intersectAccess == FileDialogPermissionAccess.None)
  123.                 return null;
  124.             else
  125.                 return new FileDialogPermission(intersectAccess);
  126.         }
  127.        
  128.         public override bool IsSubsetOf(IPermission target)
  129.         {
  130.             if (target == null) {
  131.                 // Only safe subset if this is empty
  132.                 return access == FileDialogPermissionAccess.None;
  133.             }
  134.            
  135.             try {
  136.                 FileDialogPermission operand = (FileDialogPermission)target;
  137.                 if (operand.IsUnrestricted()) {
  138.                     return true;
  139.                 }
  140.                 else if (this.IsUnrestricted()) {
  141.                     return false;
  142.                 }
  143.                 else {
  144.                     int open = (int)(access & FileDialogPermissionAccess.Open);
  145.                     int save = (int)(access & FileDialogPermissionAccess.Save);
  146.                     int openTarget = (int)(operand.Access & FileDialogPermissionAccess.Open);
  147.                     int saveTarget = (int)(operand.Access & FileDialogPermissionAccess.Save);
  148.                    
  149.                     return open <= openTarget && save <= saveTarget;
  150.                 }
  151.             }
  152.             catch (InvalidCastException) {
  153.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName));
  154.             }
  155.            
  156.         }
  157.        
  158.         public bool IsUnrestricted()
  159.         {
  160.             return access == FileDialogPermissionAccess.OpenSave;
  161.         }
  162.        
  163.         void Reset()
  164.         {
  165.             access = FileDialogPermissionAccess.None;
  166.         }
  167.        
  168.         void SetUnrestricted(bool unrestricted)
  169.         {
  170.             if (unrestricted) {
  171.                 access = FileDialogPermissionAccess.OpenSave;
  172.             }
  173.         }
  174.        
  175.         public override SecurityElement ToXml()
  176.         {
  177.             SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this, "System.Security.Permissions.FileDialogPermission");
  178.             if (!IsUnrestricted()) {
  179.                 if (access != FileDialogPermissionAccess.None) {
  180.                     esd.AddAttribute("Access", Enum.GetName(typeof(FileDialogPermissionAccess), access));
  181.                 }
  182.             }
  183.             else {
  184.                 esd.AddAttribute("Unrestricted", "true");
  185.             }
  186.             return esd;
  187.         }
  188.        
  189.         public override IPermission Union(IPermission target)
  190.         {
  191.             if (target == null) {
  192.                 return this.Copy();
  193.             }
  194.             else if (!VerifyType(target)) {
  195.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName));
  196.             }
  197.            
  198.             FileDialogPermission operand = (FileDialogPermission)target;
  199.             return new FileDialogPermission(access | operand.Access);
  200.         }
  201.        
  202.         static void VerifyAccess(FileDialogPermissionAccess access)
  203.         {
  204.             if ((access & ~FileDialogPermissionAccess.OpenSave) != 0) {
  205.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Arg_EnumIllegalVal"), (int)access));
  206.             }
  207.         }
  208.     }
  209. }

Developer Fusion