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

  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. namespace System.Security.Permissions
  16. {
  17.    
  18.     using System;
  19.     using System.IO;
  20.     using System.Security;
  21.     using System.Security.Util;
  22.     using System.Globalization;
  23.    
  24.     [Serializable()]
  25.     [System.Runtime.InteropServices.ComVisible(true)]
  26.     public enum IsolatedStorageContainment
  27.     {
  28.         None = 0,
  29.         DomainIsolationByUser = 16,
  30.         ApplicationIsolationByUser = 21,
  31.         AssemblyIsolationByUser = 32,
  32.         DomainIsolationByMachine = 48,
  33.         AssemblyIsolationByMachine = 64,
  34.         ApplicationIsolationByMachine = 69,
  35.         DomainIsolationByRoamingUser = 80,
  36.         AssemblyIsolationByRoamingUser = 96,
  37.         ApplicationIsolationByRoamingUser = 101,
  38.         AdministerIsolatedStorageByUser = 112,
  39.         //AdministerIsolatedStorageByMachine = 0x80,
  40.         UnrestrictedIsolatedStorage = 240
  41.     }
  42.    
  43.    
  44.     [Serializable(), SecurityPermissionAttribute(SecurityAction.InheritanceDemand, ControlEvidence = true, ControlPolicy = true)]
  45.     [System.Runtime.InteropServices.ComVisible(true)]
  46.     public abstract class IsolatedStoragePermission : CodeAccessPermission, IUnrestrictedPermission
  47.     {
  48.        
  49.         //------------------------------------------------------
  50.         //
  51.         // PRIVATE STATE DATA
  52.         //
  53.         //------------------------------------------------------
  54.        
  55.         /// <internalonly/>
  56.         internal long m_userQuota;
  57.         /// <internalonly/>
  58.         internal long m_machineQuota;
  59.         /// <internalonly/>
  60.         internal long m_expirationDays;
  61.         /// <internalonly/>
  62.         internal bool m_permanentData;
  63.         /// <internalonly/>
  64.         internal IsolatedStorageContainment m_allowed;
  65.        
  66.         //------------------------------------------------------
  67.         //
  68.         // CONSTRUCTORS
  69.         //
  70.         //------------------------------------------------------
  71.        
  72.         protected IsolatedStoragePermission(PermissionState state)
  73.         {
  74.             if (state == PermissionState.Unrestricted) {
  75.                 m_userQuota = Int64.MaxValue;
  76.                 m_machineQuota = Int64.MaxValue;
  77.                 m_expirationDays = Int64.MaxValue;
  78.                 m_permanentData = true;
  79.                 m_allowed = IsolatedStorageContainment.UnrestrictedIsolatedStorage;
  80.             }
  81.             else if (state == PermissionState.None) {
  82.                 m_userQuota = 0;
  83.                 m_machineQuota = 0;
  84.                 m_expirationDays = 0;
  85.                 m_permanentData = false;
  86.                 m_allowed = IsolatedStorageContainment.None;
  87.             }
  88.             else {
  89.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
  90.             }
  91.         }
  92.        
  93.        
  94.         internal IsolatedStoragePermission(IsolatedStorageContainment UsageAllowed, long ExpirationDays, bool PermanentData)
  95.         {
  96.             m_userQuota = 0;
  97.             // typical demand won't include quota
  98.             m_machineQuota = 0;
  99.             // typical demand won't include quota
  100.             m_expirationDays = ExpirationDays;
  101.             m_permanentData = PermanentData;
  102.             m_allowed = UsageAllowed;
  103.         }
  104.        
  105.        
  106.         internal IsolatedStoragePermission(IsolatedStorageContainment UsageAllowed, long ExpirationDays, bool PermanentData, long UserQuota)
  107.         {
  108.             m_machineQuota = 0;
  109.             m_userQuota = UserQuota;
  110.             m_expirationDays = ExpirationDays;
  111.             m_permanentData = PermanentData;
  112.             m_allowed = UsageAllowed;
  113.         }
  114.        
  115.        
  116.         //------------------------------------------------------
  117.         //
  118.         // PUBLIC ACCESSOR METHODS
  119.         //
  120.         //------------------------------------------------------
  121.        
  122.         // properties
  123.         public long UserQuota {
  124.             get { return m_userQuota; }
  125.             set { m_userQuota = value; }
  126.         }
  127.        
  128.        
  129.         public IsolatedStorageContainment UsageAllowed {
  130.             get { return m_allowed; }
  131.             set { m_allowed = value; }
  132.         }
  133.        
  134.        
  135.         //------------------------------------------------------
  136.         //
  137.         // CODEACCESSPERMISSION IMPLEMENTATION
  138.         //
  139.         //------------------------------------------------------
  140.        
  141.         public bool IsUnrestricted()
  142.         {
  143.             return m_allowed == IsolatedStorageContainment.UnrestrictedIsolatedStorage;
  144.         }
  145.        
  146.        
  147.         //------------------------------------------------------
  148.         //
  149.         // INTERNAL METHODS
  150.         //
  151.         //------------------------------------------------------
  152.         static internal long min(long x, long y)
  153.         {
  154.             return x > y ? y : x;
  155.         }
  156.         static internal long max(long x, long y)
  157.         {
  158.             return x < y ? y : x;
  159.         }
  160.         //------------------------------------------------------
  161.         //
  162.         // PUBLIC ENCODING METHODS
  163.         //
  164.         //------------------------------------------------------
  165.        
  166.         private const string _strUserQuota = "UserQuota";
  167.         private const string _strMachineQuota = "MachineQuota";
  168.         private const string _strExpiry = "Expiry";
  169.         private const string _strPermDat = "Permanent";
  170.        
  171.         public override SecurityElement ToXml()
  172.         {
  173.             return ToXml(this.GetType().FullName);
  174.         }
  175.        
  176.         internal SecurityElement ToXml(string permName)
  177.         {
  178.             SecurityElement esd = CodeAccessPermission.CreatePermissionElement(this, permName);
  179.             if (!IsUnrestricted()) {
  180.                 esd.AddAttribute("Allowed", Enum.GetName(typeof(IsolatedStorageContainment), m_allowed));
  181.                 if (m_userQuota > 0) {
  182.                     esd.AddAttribute(_strUserQuota, (m_userQuota).ToString(CultureInfo.InvariantCulture));
  183.                 }
  184.                 if (m_machineQuota > 0) {
  185.                     esd.AddAttribute(_strMachineQuota, (m_machineQuota).ToString(CultureInfo.InvariantCulture));
  186.                 }
  187.                 if (m_expirationDays > 0) {
  188.                     esd.AddAttribute(_strExpiry, (m_expirationDays).ToString(CultureInfo.InvariantCulture));
  189.                 }
  190.                 if (m_permanentData) {
  191.                     esd.AddAttribute(_strPermDat, (m_permanentData).ToString());
  192.                 }
  193.             }
  194.             else {
  195.                 esd.AddAttribute("Unrestricted", "true");
  196.             }
  197.             return esd;
  198.         }
  199.        
  200.        
  201.         public override void FromXml(SecurityElement esd)
  202.         {
  203.             CodeAccessPermission.ValidateElement(esd, this);
  204.            
  205.             m_allowed = IsolatedStorageContainment.None;
  206.             // default if no match
  207.             if (XMLUtil.IsUnrestricted(esd)) {
  208.                 m_allowed = IsolatedStorageContainment.UnrestrictedIsolatedStorage;
  209.             }
  210.             else {
  211.                 string allowed = esd.Attribute("Allowed");
  212.                
  213.                 if (allowed != null)
  214.                     m_allowed = (IsolatedStorageContainment)Enum.Parse(typeof(IsolatedStorageContainment), allowed);
  215.             }
  216.            
  217.             if (m_allowed == IsolatedStorageContainment.UnrestrictedIsolatedStorage) {
  218.                 m_userQuota = Int64.MaxValue;
  219.                 m_machineQuota = Int64.MaxValue;
  220.                 m_expirationDays = Int64.MaxValue;
  221.                 m_permanentData = true;
  222.             }
  223.             else {
  224.                 string param;
  225.                 param = esd.Attribute(_strUserQuota);
  226.                 m_userQuota = param != null ? Int64.Parse(param, CultureInfo.InvariantCulture) : 0;
  227.                 param = esd.Attribute(_strMachineQuota);
  228.                 m_machineQuota = param != null ? Int64.Parse(param, CultureInfo.InvariantCulture) : 0;
  229.                 param = esd.Attribute(_strExpiry);
  230.                 m_expirationDays = param != null ? Int64.Parse(param, CultureInfo.InvariantCulture) : 0;
  231.                 param = esd.Attribute(_strPermDat);
  232.                 m_permanentData = param != null ? (Boolean.Parse(param)) : false;
  233.             }
  234.         }
  235.     }
  236. }

Developer Fusion