The Labs \ Source Viewer \ SSCLI \ System.IO.IsolatedStorage \ IsolatedStorageScope

  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. /*============================================================
  16. *
  17. * Class:  IsolatedStorage
  18. *
  19. *
  20. * Purpose: Provides access to Persisted Application / Assembly data
  21. *
  22. * Date:  Feb 15, 2000
  23. *
  24. ===========================================================*/
  25. namespace System.IO.IsolatedStorage
  26. {
  27.    
  28.     using System;
  29.     using System.IO;
  30.     using System.Text;
  31.     using System.Threading;
  32.     using System.Reflection;
  33.     using System.Collections;
  34.     using System.Security;
  35.     using System.Security.Policy;
  36.     using System.Security.Permissions;
  37.     using System.Security.Cryptography;
  38.     using System.Runtime.Serialization;
  39.     using System.Runtime.CompilerServices;
  40.     using System.Runtime.Serialization.Formatters.Binary;
  41.     using System.Runtime.InteropServices;
  42.     using Microsoft.Win32;
  43.    
  44.     [Flags(), Serializable()]
  45.     [System.Runtime.InteropServices.ComVisible(true)]
  46.     public enum IsolatedStorageScope
  47.     {
  48.         // Dependency in native : COMIsolatedStorage.h
  49.        
  50.         None = 0,
  51.         User = 1,
  52.         Domain = 2,
  53.         Assembly = 4,
  54.         Roaming = 8,
  55.         Machine = 16,
  56.         Application = 32
  57.     }
  58.    
  59.     // not serializable
  60.     [System.Runtime.InteropServices.ComVisible(true)]
  61.     public abstract class IsolatedStorage : MarshalByRefObject
  62.     {
  63.         // Helper constants
  64.         internal const IsolatedStorageScope c_Assembly = (IsolatedStorageScope.User | IsolatedStorageScope.Assembly);
  65.        
  66.         internal const IsolatedStorageScope c_Domain = (IsolatedStorageScope.User | IsolatedStorageScope.Assembly | IsolatedStorageScope.Domain);
  67.        
  68.         internal const IsolatedStorageScope c_AssemblyRoaming = (IsolatedStorageScope.Roaming | IsolatedStorageScope.User | IsolatedStorageScope.Assembly);
  69.        
  70.         internal const IsolatedStorageScope c_DomainRoaming = (IsolatedStorageScope.Roaming | IsolatedStorageScope.User | IsolatedStorageScope.Assembly | IsolatedStorageScope.Domain);
  71.        
  72.         internal const IsolatedStorageScope c_MachineAssembly = (IsolatedStorageScope.Machine | IsolatedStorageScope.Assembly);
  73.        
  74.         internal const IsolatedStorageScope c_MachineDomain = (IsolatedStorageScope.Machine | IsolatedStorageScope.Assembly | IsolatedStorageScope.Domain);
  75.        
  76.         internal const IsolatedStorageScope c_AppUser = (IsolatedStorageScope.Application | IsolatedStorageScope.User);
  77.        
  78.         internal const IsolatedStorageScope c_AppMachine = (IsolatedStorageScope.Application | IsolatedStorageScope.Machine);
  79.        
  80.         internal const IsolatedStorageScope c_AppUserRoaming = (IsolatedStorageScope.Roaming | IsolatedStorageScope.Application | IsolatedStorageScope.User);
  81.        
  82.         private const string s_StrongName = "StrongName";
  83.         private const string s_Site = "Site";
  84.         private const string s_Url = "Url";
  85.         private const string s_Zone = "Zone";
  86.        
  87.         private static char[] s_Base32Char = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
  88.         'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
  89.         'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3',
  90.         '4', '5'};
  91.        
  92.         private ulong m_Quota;
  93.         private bool m_ValidQuota;
  94.        
  95.         private object m_DomainIdentity;
  96.         private object m_AssemIdentity;
  97.         private object m_AppIdentity;
  98.        
  99.         private string m_DomainName;
  100.         private string m_AssemName;
  101.         private string m_AppName;
  102.        
  103.         private IsolatedStorageScope m_Scope;
  104.        
  105.         private static IsolatedStorageFilePermission s_PermDomain;
  106.         private static IsolatedStorageFilePermission s_PermMachineDomain;
  107.         private static IsolatedStorageFilePermission s_PermDomainRoaming;
  108.         private static IsolatedStorageFilePermission s_PermAssem;
  109.         private static IsolatedStorageFilePermission s_PermMachineAssem;
  110.         private static IsolatedStorageFilePermission s_PermAssemRoaming;
  111.         private static IsolatedStorageFilePermission s_PermAppUser;
  112.         private static IsolatedStorageFilePermission s_PermAppMachine;
  113.         private static IsolatedStorageFilePermission s_PermAppUserRoaming;
  114.        
  115.         private static SecurityPermission s_PermControlEvidence;
  116.         private static PermissionSet s_PermReflection;
  117.         private static PermissionSet s_PermUnrestricted;
  118.         private static PermissionSet s_PermExecution;
  119.        
  120.         #if _DEBUG
  121.         private static bool s_fDebug = false;
  122.         private static int s_iDebug = 0;
  123.         #endif
  124.        
  125.         // This one should be a macro, expecting JIT to inline this.
  126.         static internal bool IsRoaming(IsolatedStorageScope scope)
  127.         {
  128.             return ((scope & IsolatedStorageScope.Roaming) != 0);
  129.         }
  130.        
  131.         internal bool IsRoaming()
  132.         {
  133.             return ((m_Scope & IsolatedStorageScope.Roaming) != 0);
  134.         }
  135.        
  136.         // This one should be a macro, expecting JIT to inline this.
  137.         static internal bool IsDomain(IsolatedStorageScope scope)
  138.         {
  139.             return ((scope & IsolatedStorageScope.Domain) != 0);
  140.         }
  141.        
  142.         internal bool IsDomain()
  143.         {
  144.             return ((m_Scope & IsolatedStorageScope.Domain) != 0);
  145.         }
  146.        
  147.        
  148.         // This one should be a macro, expecting JIT to inline this.
  149.         static internal bool IsMachine(IsolatedStorageScope scope)
  150.         {
  151.             return ((scope & IsolatedStorageScope.Machine) != 0);
  152.         }
  153.        
  154.         internal bool IsAssembly()
  155.         {
  156.             return ((m_Scope & IsolatedStorageScope.Assembly) != 0);
  157.         }
  158.        
  159.        
  160.         // This one should be a macro, expecting JIT to inline this.
  161.         static internal bool IsApp(IsolatedStorageScope scope)
  162.         {
  163.             return ((scope & IsolatedStorageScope.Application) != 0);
  164.         }
  165.        
  166.         internal bool IsApp()
  167.         {
  168.             return ((m_Scope & IsolatedStorageScope.Application) != 0);
  169.         }
  170.        
  171.         private string GetNameFromID(string typeID, string instanceID)
  172.         {
  173.             StringBuilder sb = new StringBuilder();
  174.             sb.Append(typeID);
  175.             sb.Append(SeparatorInternal);
  176.             sb.Append(instanceID);
  177.            
  178.             return sb.ToString();
  179.         }
  180.        
  181.         private static string GetPredefinedTypeName(object o)
  182.         {
  183.             if (o is StrongName)
  184.                 return s_StrongName;
  185.             else if (o is Url)
  186.                 return s_Url;
  187.             else if (o is Site)
  188.                 return s_Site;
  189.             else if (o is Zone)
  190.                 return s_Zone;
  191.            
  192.             return null;
  193.         }
  194.        
  195.         static internal string GetHash(Stream s)
  196.         {
  197.             const int MAX_BUFFER_SIZE = 1024;
  198.             byte[] buffer = new byte[MAX_BUFFER_SIZE];
  199.            
  200.             // 160 bits SHA1 output as defined in the Secure Hash Standard
  201.             const int MESSAGE_DIGEST_LENGTH = 20;
  202.             int digestLength = 0;
  203.             byte[] digest = new byte[MESSAGE_DIGEST_LENGTH];
  204.            
  205.             IntPtr hProv = (IntPtr)0;
  206.             IntPtr hHash = (IntPtr)0;
  207.            
  208.             if (Win32Native.CryptAcquireContext(out hProv, null, null, 0, 0) == false)
  209.                 throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_Exception"));
  210.            
  211.             if (Win32Native.CryptCreateHash(hProv, Win32Native.CALG_SHA1, (IntPtr)0, 0, out hHash) == false)
  212.                 throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_Exception"));
  213.            
  214.             int bytesRead;
  215.             do {
  216.                 bytesRead = s.Read(buffer, 0, MAX_BUFFER_SIZE);
  217.                 if (bytesRead > 0) {
  218.                     if (Win32Native.CryptHashData(hHash, buffer, bytesRead, 0) == false) {
  219.                         throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_Exception"));
  220.                     }
  221.                 }
  222.             }
  223.             while (bytesRead > 0);
  224.            
  225.             // perform a sanity check to make sure the digest size equals MESSAGE_DIGEST_LENGTH
  226.             int fourBytes = 4;
  227.             if (Win32Native.CryptGetHashParam(hHash, Win32Native.HP_HASHSIZE, out digestLength, ref fourBytes, 0) == false || (digestLength != MESSAGE_DIGEST_LENGTH)) {
  228.                 throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_Exception"));
  229.             }
  230.            
  231.             if (Win32Native.CryptGetHashParam(hHash, Win32Native.HP_HASHVAL, digest, ref digestLength, 0) == false)
  232.                 throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_Exception"));
  233.            
  234.             if (Win32Native.CryptDestroyHash(hHash) == false)
  235.                 throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_Exception"));
  236.            
  237.             if (Win32Native.CryptReleaseContext(hProv, 0) == false)
  238.                 throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_Exception"));
  239.            
  240.             return ToBase32StringSuitableForDirName(digest);
  241.         }
  242.        
  243.         static internal string ToBase32StringSuitableForDirName(byte[] buff)
  244.         {
  245.             // This routine is optimised to be used with buffs of length 20
  246.             BCLDebug.Assert(((buff.Length % 5) == 0), "Unexpected hash length");
  247.            
  248.             #if _DEBUG
  249.             if (s_fDebug) {
  250.                 if (s_iDebug >= 10) {
  251.                     Console.Write("Stream : ");
  252.                     for (int j = 0; j < buff.Length; ++j)
  253.                         Console.Write("{0} ", buff[j]);
  254.                    
  255.                     Console.WriteLine("");
  256.                 }
  257.             }
  258.             #endif
  259.             StringBuilder sb = new StringBuilder();
  260.             byte b0;
  261.             byte b1;
  262.             byte b2;
  263.             byte b3;
  264.             byte b4;
  265.             int l;
  266.             int i;
  267.            
  268.             l = buff.Length;
  269.             i = 0;
  270.            
  271.             // Create l chars using the last 5 bits of each byte.
  272.             // Consume 3 MSB bits 5 bytes at a time.
  273.            
  274.             do {
  275.                 b0 = (i < l) ? buff[i++] : (byte)0;
  276.                 b1 = (i < l) ? buff[i++] : (byte)0;
  277.                 b2 = (i < l) ? buff[i++] : (byte)0;
  278.                 b3 = (i < l) ? buff[i++] : (byte)0;
  279.                 b4 = (i < l) ? buff[i++] : (byte)0;
  280.                
  281.                 // Consume the 5 Least significant bits of each byte
  282.                 sb.Append(s_Base32Char[b0 & 31]);
  283.                 sb.Append(s_Base32Char[b1 & 31]);
  284.                 sb.Append(s_Base32Char[b2 & 31]);
  285.                 sb.Append(s_Base32Char[b3 & 31]);
  286.                 sb.Append(s_Base32Char[b4 & 31]);
  287.                
  288.                 // Consume 3 MSB of b0, b1, MSB bits 6, 7 of b3, b4
  289.                 sb.Append(s_Base32Char[(((b0 & 224) >> 5) | ((b3 & 96) >> 2))]);
  290.                
  291.                 sb.Append(s_Base32Char[(((b1 & 224) >> 5) | ((b4 & 96) >> 2))]);
  292.                
  293.                 // Consume 3 MSB bits of b2, 1 MSB bit of b3, b4
  294.                
  295.                 b2 >>= 5;
  296.                
  297.                 BCLDebug.Assert(((b2 & 248) == 0), "Unexpected set bits");
  298.                
  299.                 if ((b3 & 128) != 0)
  300.                     b2 |= 8;
  301.                 if ((b4 & 128) != 0)
  302.                     b2 |= 16;
  303.                
  304.                 sb.Append(s_Base32Char[b2]);
  305.                
  306.             }
  307.             while (i < l);
  308.            
  309.             #if _DEBUG
  310.             if (s_fDebug) {
  311.                 if (s_iDebug >= 10)
  312.                     Console.WriteLine("Hash : " + sb.ToString());
  313.             }
  314.             #endif
  315.             return sb.ToString();
  316.         }
  317.        
  318.        
  319.         private static bool IsValidName(string s)
  320.         {
  321.             for (int i = 0; i < s.Length; ++i) {
  322.                 if (!Char.IsLetter(s[i]) && !Char.IsDigit(s[i]))
  323.                     return false;
  324.             }
  325.            
  326.             return true;
  327.         }
  328.        
  329.         private static PermissionSet GetReflectionPermission()
  330.         {
  331.             // Don't sync. OK to create this object more than once.
  332.             if (s_PermReflection == null)
  333.                 s_PermReflection = new PermissionSet(PermissionState.Unrestricted);
  334.            
  335.             return s_PermReflection;
  336.         }
  337.        
  338.         private static SecurityPermission GetControlEvidencePermission()
  339.         {
  340.             // Don't sync. OK to create this object more than once.
  341.             if (s_PermControlEvidence == null)
  342.                 s_PermControlEvidence = new SecurityPermission(SecurityPermissionFlag.ControlEvidence);
  343.            
  344.             return s_PermControlEvidence;
  345.         }
  346.        
  347.         private static PermissionSet GetExecutionPermission()
  348.         {
  349.             // Don't sync. OK to create this object more than once.
  350.             if (s_PermExecution == null) {
  351.                 s_PermExecution = new PermissionSet(PermissionState.None);
  352.                 s_PermExecution.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution));
  353.             }
  354.            
  355.             return s_PermExecution;
  356.         }
  357.        
  358.         private static PermissionSet GetUnrestricted()
  359.         {
  360.             // Don't sync. OK to create this object more than once.
  361.             if (s_PermUnrestricted == null)
  362.                 s_PermUnrestricted = new PermissionSet(PermissionState.Unrestricted);
  363.            
  364.             return s_PermUnrestricted;
  365.         }
  366.        
  367.         protected virtual char SeparatorExternal {
  368.             get { return System.IO.Path.DirectorySeparatorChar; }
  369.         }
  370.        
  371.         protected virtual char SeparatorInternal {
  372.             get { return '.'; }
  373.         }
  374.        
  375.         // gets "amount of space / resource used"
  376.        
  377.         [CLSCompliant(false)]
  378.         public virtual ulong MaximumSize {
  379.             get {
  380.                 if (m_ValidQuota)
  381.                     return m_Quota;
  382.                
  383.                 throw new InvalidOperationException(Environment.GetResourceString("IsolatedStorage_QuotaIsUndefined"));
  384.             }
  385.         }
  386.        
  387.         [CLSCompliant(false)]
  388.         public virtual ulong CurrentSize {
  389.             get {
  390.                 throw new InvalidOperationException(Environment.GetResourceString("IsolatedStorage_CurrentSizeUndefined"));
  391.             }
  392.         }
  393.        
  394.         public object DomainIdentity {
  395.             [SecurityPermissionAttribute(SecurityAction.Demand, Flags = SecurityPermissionFlag.ControlPolicy)]
  396.             get {
  397.                
  398.                 if (IsDomain())
  399.                     return m_DomainIdentity;
  400.                
  401.                 throw new InvalidOperationException(Environment.GetResourceString("IsolatedStorage_DomainUndefined"));
  402.             }
  403.         }
  404.        
  405.         [ComVisible(false)]
  406.         public object ApplicationIdentity {
  407.             [SecurityPermissionAttribute(SecurityAction.Demand, Flags = SecurityPermissionFlag.ControlPolicy)]
  408.             get {
  409.                
  410.                 if (IsApp())
  411.                     return m_AppIdentity;
  412.                
  413.                 throw new InvalidOperationException(Environment.GetResourceString("IsolatedStorage_ApplicationUndefined"));
  414.             }
  415.         }
  416.        
  417.         public object AssemblyIdentity {
  418.             [SecurityPermissionAttribute(SecurityAction.Demand, Flags = SecurityPermissionFlag.ControlPolicy)]
  419.             get {
  420.                
  421.                 if (IsAssembly())
  422.                     return m_AssemIdentity;
  423.                
  424.                 throw new InvalidOperationException(Environment.GetResourceString("IsolatedStorage_AssemblyUndefined"));
  425.             }
  426.         }
  427.        
  428.         // Returns the AppDomain Stream (if present).
  429.         // Sets assem stream
  430.         internal MemoryStream GetIdentityStream(IsolatedStorageScope scope)
  431.         {
  432.             BinaryFormatter bSer;
  433.             MemoryStream ms;
  434.             object o;
  435.            
  436.             GetReflectionPermission().Assert();
  437.            
  438.             bSer = new BinaryFormatter();
  439.             ms = new MemoryStream();
  440.             if (IsApp(scope))
  441.                 o = m_AppIdentity;
  442.             else if (IsDomain(scope))
  443.                 o = m_DomainIdentity;
  444.             else
  445.                 o = m_AssemIdentity;
  446.            
  447.             if (o != null)
  448.                 bSer.Serialize(ms, o);
  449.             ms.Position = 0;
  450.             return ms;
  451.         }
  452.        
  453.         public IsolatedStorageScope Scope {
  454.             get { return m_Scope; }
  455.         }
  456.        
  457.         internal string DomainName {
  458.             get {
  459.                
  460.                 if (IsDomain())
  461.                     return m_DomainName;
  462.                
  463.                 throw new InvalidOperationException(Environment.GetResourceString("IsolatedStorage_DomainUndefined"));
  464.             }
  465.         }
  466.        
  467.         internal string AssemName {
  468.             get {
  469.                
  470.                 if (IsAssembly())
  471.                     return m_AssemName;
  472.                
  473.                 throw new InvalidOperationException(Environment.GetResourceString("IsolatedStorage_AssemblyUndefined"));
  474.             }
  475.         }
  476.        
  477.         internal string AppName {
  478.             get {
  479.                
  480.                 if (IsApp())
  481.                     return m_AppName;
  482.                
  483.                 throw new InvalidOperationException(Environment.GetResourceString("IsolatedStorage_ApplicationUndefined"));
  484.             }
  485.         }
  486.        
  487.         protected void InitStore(IsolatedStorageScope scope, Type domainEvidenceType, Type assemblyEvidenceType)
  488.         {
  489.             Assembly assem;
  490.             AppDomain domain;
  491.             PermissionSet psAllowed;
  492.             PermissionSet psDenied;
  493.            
  494.             psAllowed = null;
  495.             psDenied = null;
  496.            
  497.             assem = nGetCaller();
  498.            
  499.             GetControlEvidencePermission().Assert();
  500.            
  501.             if (IsDomain(scope)) {
  502.                 domain = Thread.GetDomain();
  503.                
  504.                 // No quota for roaming
  505.                 if (!IsRoaming(scope)) {
  506.                     domain.nGetGrantSet(out psAllowed, out psDenied);
  507.                    
  508.                     if (psAllowed == null)
  509.                         throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_DomainGrantSet"));
  510.                 }
  511.                
  512.                 _InitStore(scope, domain.Evidence, domainEvidenceType, assem.Evidence, assemblyEvidenceType, null, null);
  513.             }
  514.             else {
  515.                 // No quota for roaming
  516.                 if (!IsRoaming(scope)) {
  517.                     assem.nGetGrantSet(out psAllowed, out psDenied);
  518.                    
  519.                     if (psAllowed == null)
  520.                         throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_AssemblyGrantSet"));
  521.                 }
  522.                
  523.                 _InitStore(scope, null, null, assem.Evidence, assemblyEvidenceType, null, null);
  524.             }
  525.            
  526.             SetQuota(psAllowed, psDenied);
  527.         }
  528.        
  529.         protected void InitStore(IsolatedStorageScope scope, Type appEvidenceType)
  530.         {
  531.             Assembly assem;
  532.             AppDomain domain;
  533.             PermissionSet psAllowed;
  534.             PermissionSet psDenied;
  535.            
  536.             psAllowed = null;
  537.             psDenied = null;
  538.            
  539.             assem = nGetCaller();
  540.            
  541.             GetControlEvidencePermission().Assert();
  542.            
  543.             if (IsApp(scope)) {
  544.                 domain = Thread.GetDomain();
  545.                
  546.                 // No quota for roaming
  547.                 if (!IsRoaming(scope)) {
  548.                     domain.nGetGrantSet(out psAllowed, out psDenied);
  549.                     if (psAllowed == null)
  550.                         throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_DomainGrantSet"));
  551.                 }
  552.                
  553.                 throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_ApplicationMissingIdentity"));
  554.             }
  555.             SetQuota(psAllowed, psDenied);
  556.         }
  557.        
  558.         internal void InitStore(IsolatedStorageScope scope, object domain, object assem, object app)
  559.         {
  560.             Assembly callerAssembly;
  561.             PermissionSet psAllowed = null;
  562.             PermissionSet psDenied = null;
  563.             Evidence domainEv = null;
  564.             Evidence assemEv = null;
  565.             Evidence appEv = null;
  566.            
  567.             if (IsApp(scope)) {
  568.                 appEv = new Evidence();
  569.                 appEv.AddHost(app);
  570.             }
  571.             else {
  572.                 assemEv = new Evidence();
  573.                 assemEv.AddHost(assem);
  574.                
  575.                 if (IsDomain(scope)) {
  576.                     domainEv = new Evidence();
  577.                     domainEv.AddHost(domain);
  578.                 }
  579.             }
  580.            
  581.             _InitStore(scope, domainEv, null, assemEv, null, appEv, null);
  582.            
  583.             // Set the quota based on the caller, not the evidence supplied
  584.            
  585.             // No quota for roaming
  586.             if (!IsRoaming(scope)) {
  587.                 callerAssembly = nGetCaller();
  588.                
  589.                 GetControlEvidencePermission().Assert();
  590.                 callerAssembly.nGetGrantSet(out psAllowed, out psDenied);
  591.                
  592.                 if (psAllowed == null)
  593.                     throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_AssemblyGrantSet"));
  594.             }
  595.            
  596.             // This can be called only by trusted assemblies.
  597.             // This quota really does not correspond to the permissions
  598.             // granted for this evidence.
  599.             SetQuota(psAllowed, psDenied);
  600.         }
  601.        
  602.         internal void InitStore(IsolatedStorageScope scope, Evidence domainEv, Type domainEvidenceType, Evidence assemEv, Type assemEvidenceType, Evidence appEv, Type appEvidenceType)
  603.         {
  604.             PermissionSet psAllowed = null;
  605.             PermissionSet psDenied = null;
  606.            
  607.             if (!IsRoaming(scope)) {
  608.                 if (IsApp(scope)) {
  609.                     psAllowed = SecurityManager.ResolvePolicy(appEv, GetExecutionPermission(), GetUnrestricted(), null, out psDenied);
  610.                    
  611.                     if (psAllowed == null)
  612.                         throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_ApplicationGrantSet"));
  613.                 }
  614.                 else if (IsDomain(scope)) {
  615.                     psAllowed = SecurityManager.ResolvePolicy(domainEv, GetExecutionPermission(), GetUnrestricted(), null, out psDenied);
  616.                    
  617.                     if (psAllowed == null)
  618.                         throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_DomainGrantSet"));
  619.                 }
  620.                 else {
  621.                     psAllowed = SecurityManager.ResolvePolicy(assemEv, GetExecutionPermission(), GetUnrestricted(), null, out psDenied);
  622.                    
  623.                     if (psAllowed == null)
  624.                         throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_AssemblyGrantSet"));
  625.                 }
  626.             }
  627.            
  628.             _InitStore(scope, domainEv, domainEvidenceType, assemEv, assemEvidenceType, appEv, appEvidenceType);
  629.            
  630.             SetQuota(psAllowed, psDenied);
  631.         }
  632.        
  633.         internal bool InitStore(IsolatedStorageScope scope, Stream domain, Stream assem, Stream app, string domainName, string assemName, string appName)
  634.         {
  635.             BinaryFormatter bSer;
  636.            
  637.             try {
  638.                
  639.                 GetReflectionPermission().Assert();
  640.                
  641.                 bSer = new BinaryFormatter();
  642.                
  643.                 if (IsApp(scope)) {
  644.                     // Get the Application Info
  645.                     m_AppIdentity = bSer.Deserialize(app);
  646.                     m_AppName = appName;
  647.                 }
  648.                 else {
  649.                     // Get the Assem Info
  650.                     m_AssemIdentity = bSer.Deserialize(assem);
  651.                     m_AssemName = assemName;
  652.                    
  653.                     if (IsDomain(scope)) {
  654.                         // Get the AppDomain Info
  655.                         m_DomainIdentity = bSer.Deserialize(domain);
  656.                         m_DomainName = domainName;
  657.                     }
  658.                 }
  659.                
  660.             }
  661.             catch {
  662.                 return false;
  663.             }
  664.            
  665.             BCLDebug.Assert(m_ValidQuota == false, "Quota should be invalid here");
  666.            
  667.             m_Scope = scope;
  668.            
  669.             return true;
  670.         }
  671.        
  672.         private void _InitStore(IsolatedStorageScope scope, Evidence domainEv, Type domainEvidenceType, Evidence assemEv, Type assemblyEvidenceType, Evidence appEv, Type appEvidenceType)
  673.         {
  674.            
  675.             VerifyScope(scope);
  676.            
  677.             // If its app-scoped, we only use the appId and appName. Else assume assembly evidence present
  678.             // and check if we need domain scoping too
  679.            
  680.             // Input arg checks
  681.             if (IsApp(scope)) {
  682.                 if (appEv == null)
  683.                     throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_ApplicationMissingIdentity"));
  684.             }
  685.             else {
  686.                 if (assemEv == null)
  687.                     throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_AssemblyMissingIdentity"));
  688.                
  689.                 if (IsDomain(scope) && (domainEv == null))
  690.                     throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_DomainMissingIdentity"));
  691.             }
  692.            
  693.            
  694.             // Security checks
  695.             DemandPermission(scope);
  696.            
  697.             string typeHash = null;
  698.             string instanceHash = null;
  699.            
  700.             if (IsApp(scope)) {
  701.                 m_AppIdentity = GetAccountingInfo(appEv, appEvidenceType, IsolatedStorageScope.Application, out typeHash, out instanceHash);
  702.                 m_AppName = GetNameFromID(typeHash, instanceHash);
  703.             }
  704.             else {
  705.                 m_AssemIdentity = GetAccountingInfo(assemEv, assemblyEvidenceType, IsolatedStorageScope.Assembly, out typeHash, out instanceHash);
  706.                
  707.                 m_AssemName = GetNameFromID(typeHash, instanceHash);
  708.                
  709.                 if (IsDomain(scope)) {
  710.                     m_DomainIdentity = GetAccountingInfo(domainEv, domainEvidenceType, IsolatedStorageScope.Domain, out typeHash, out instanceHash);
  711.                    
  712.                     m_DomainName = GetNameFromID(typeHash, instanceHash);
  713.                 }
  714.             }
  715.             m_Scope = scope;
  716.         }
  717.        
  718.         private static object GetAccountingInfo(Evidence evidence, Type evidenceType, IsolatedStorageScope fAssmDomApp, out string typeName, out string instanceName)
  719.         {
  720.             object o;
  721.             object oNormalized = null;
  722.            
  723.             MemoryStream ms;
  724.             BinaryWriter bw;
  725.             BinaryFormatter bSer;
  726.            
  727.             o = _GetAccountingInfo(evidence, evidenceType, fAssmDomApp, out oNormalized);
  728.            
  729.             // Get the type name
  730.             typeName = GetPredefinedTypeName(o);
  731.            
  732.             if (typeName == null) {
  733.                 // This is not a predefined type. Serialize the type
  734.                 // and get a hash for the serialized stream
  735.                
  736.                 GetReflectionPermission().Assert();
  737.                 ms = new MemoryStream();
  738.                 bSer = new BinaryFormatter();
  739.                 bSer.Serialize(ms, o.GetType());
  740.                 ms.Position = 0;
  741.                 typeName = GetHash(ms);
  742.                
  743.                 #if _DEBUG
  744.                 DebugLog(o.GetType(), ms);
  745.                 #endif
  746.             }
  747.            
  748.             instanceName = null;
  749.            
  750.             // Get the normalized instance name if present.
  751.             if (oNormalized != null) {
  752.                 if (oNormalized is Stream) {
  753.                     instanceName = GetHash((Stream)oNormalized);
  754.                 }
  755.                 else if (oNormalized is string) {
  756.                     if (IsValidName((string)oNormalized)) {
  757.                         instanceName = (string)oNormalized;
  758.                     }
  759.                     else {
  760.                         // The normalized name has illegal chars
  761.                         // serialize and get the hash.
  762.                        
  763.                         ms = new MemoryStream();
  764.                         bw = new BinaryWriter(ms);
  765.                         bw.Write((string)oNormalized);
  766.                         ms.Position = 0;
  767.                         instanceName = GetHash(ms);
  768.                         #if _DEBUG
  769.                         DebugLog(oNormalized, ms);
  770.                         #endif
  771.                     }
  772.                 }
  773.                
  774.             }
  775.             else {
  776.                 oNormalized = o;
  777.             }
  778.            
  779.             if (instanceName == null) {
  780.                 // Serialize the instance and get the hash for the
  781.                 // serialized stream
  782.                
  783.                 GetReflectionPermission().Assert();
  784.                 ms = new MemoryStream();
  785.                 bSer = new BinaryFormatter();
  786.                 bSer.Serialize(ms, oNormalized);
  787.                 ms.Position = 0;
  788.                 instanceName = GetHash(ms);
  789.                
  790.                 #if _DEBUG
  791.                 DebugLog(oNormalized, ms);
  792.                 #endif
  793.             }
  794.            
  795.             return o;
  796.         }
  797.        
  798.         private static object _GetAccountingInfo(Evidence evidence, Type evidenceType, IsolatedStorageScope fAssmDomApp, out object oNormalized)
  799.         {
  800.             object o = null;
  801.             IEnumerator e;
  802.            
  803.             BCLDebug.Assert(evidence != null, "evidence != null");
  804.            
  805.             e = evidence.GetHostEnumerator();
  806.            
  807.             if (evidenceType == null) {
  808.                 // Caller does not have any preference
  809.                 // Order of preference is Strong Name, Url, Site
  810.                
  811.                 StrongName sn = null;
  812.                 Url url = null;
  813.                 Site site = null;
  814.                 Zone zone = null;
  815.                
  816.                 while (e.MoveNext()) {
  817.                     o = e.Current;
  818.                    
  819.                     if (o is StrongName)
  820.                         sn = (StrongName)o;
  821.                     else if (o is Url)
  822.                         url = (Url)o;
  823.                     else if (o is Site)
  824.                         site = (Site)o;
  825.                     else if (o is Zone)
  826.                         zone = (Zone)o;
  827.                 }
  828.                
  829.                 if (sn != null) {
  830.                     o = sn;
  831.                 }
  832.                 else if (url != null) {
  833.                     o = url;
  834.                 }
  835.                 else if (site != null) {
  836.                     o = site;
  837.                 }
  838.                 else if (zone != null) {
  839.                     o = zone;
  840.                 }
  841.                 else {
  842.                     // The evidence object can have tons of other objects
  843.                     // creatd by the policy system. Ignore those.
  844.                    
  845.                     if (fAssmDomApp == IsolatedStorageScope.Domain)
  846.                         throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_DomainNoEvidence"));
  847.                     else if (fAssmDomApp == IsolatedStorageScope.Application)
  848.                         throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_ApplicationNoEvidence"));
  849.                     else
  850.                         throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_AssemblyNoEvidence"));
  851.                 }
  852.             }
  853.             else {
  854.                 object obj;
  855.                 while (e.MoveNext()) {
  856.                     obj = e.Current;
  857.                    
  858.                     if (obj.GetType().Equals(evidenceType)) {
  859.                         o = obj;
  860.                         break;
  861.                     }
  862.                 }
  863.                
  864.                 if (o == null) {
  865.                     if (fAssmDomApp == IsolatedStorageScope.Domain)
  866.                         throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_DomainNoEvidence"));
  867.                     else if (fAssmDomApp == IsolatedStorageScope.Application)
  868.                         throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_ApplicationNoEvidence"));
  869.                     else
  870.                         throw new IsolatedStorageException(Environment.GetResourceString("IsolatedStorage_AssemblyNoEvidence"));
  871.                 }
  872.             }
  873.            
  874.             // For startup Perf, Url, Site, StrongName types don't implement
  875.             // INormalizeForIsolatedStorage interface, instead they have
  876.             // Normalize() method.
  877.            
  878.             if (o is INormalizeForIsolatedStorage) {
  879.                 oNormalized = ((INormalizeForIsolatedStorage)o).Normalize();
  880.             }
  881.             else if (o is StrongName) {
  882.                 oNormalized = ((StrongName)o).Normalize();
  883.             }
  884.             else if (o is Url) {
  885.                 oNormalized = ((Url)o).Normalize();
  886.             }
  887.             else if (o is Site) {
  888.                 oNormalized = ((Site)o).Normalize();
  889.             }
  890.             else if (o is Zone) {
  891.                 oNormalized = ((Zone)o).Normalize();
  892.             }
  893.             else {
  894.                 oNormalized = null;
  895.             }
  896.            
  897.             return o;
  898.         }
  899.        
  900.         private static void DemandPermission(IsolatedStorageScope scope)
  901.         {
  902.             IsolatedStorageFilePermission ip = null;
  903.            
  904.             // Ok to create more than one instnace of s_PermXXX, the last one
  905.             // will be shared. No need to synchronize.
  906.            
  907.             // First check for permissions
  908.            
  909.             switch (scope) {
  910.                 case c_Domain:
  911.                    
  912.                     if (s_PermDomain == null)
  913.                         s_PermDomain = new IsolatedStorageFilePermission(IsolatedStorageContainment.DomainIsolationByUser, 0, false);
  914.                     ip = s_PermDomain;
  915.                     break;
  916.                 case c_Assembly:
  917.                    
  918.                     if (s_PermAssem == null)
  919.                         s_PermAssem = new IsolatedStorageFilePermission(IsolatedStorageContainment.AssemblyIsolationByUser, 0, false);
  920.                     ip = s_PermAssem;
  921.                     break;
  922.                 case c_DomainRoaming:
  923.                    
  924.                     if (s_PermDomainRoaming == null)
  925.                         s_PermDomainRoaming = new IsolatedStorageFilePermission(IsolatedStorageContainment.DomainIsolationByRoamingUser, 0, false);
  926.                     ip = s_PermDomainRoaming;
  927.                     break;
  928.                 case c_AssemblyRoaming:
  929.                    
  930.                     if (s_PermAssemRoaming == null)
  931.                         s_PermAssemRoaming = new IsolatedStorageFilePermission(IsolatedStorageContainment.AssemblyIsolationByRoamingUser, 0, false);
  932.                     ip = s_PermAssemRoaming;
  933.                     break;
  934.                 case c_MachineDomain:
  935.                    
  936.                     if (s_PermMachineDomain == null)
  937.                         s_PermMachineDomain = new IsolatedStorageFilePermission(IsolatedStorageContainment.DomainIsolationByMachine, 0, false);
  938.                     ip = s_PermMachineDomain;
  939.                     break;
  940.                 case c_MachineAssembly:
  941.                    
  942.                     if (s_PermMachineAssem == null)
  943.                         s_PermMachineAssem = new IsolatedStorageFilePermission(IsolatedStorageContainment.AssemblyIsolationByMachine, 0, false);
  944.                     ip = s_PermMachineAssem;
  945.                     break;
  946.                 case c_AppUser:
  947.                    
  948.                     if (s_PermAppUser == null)
  949.                         s_PermAppUser = new IsolatedStorageFilePermission(IsolatedStorageContainment.ApplicationIsolationByUser, 0, false);
  950.                     ip = s_PermAppUser;
  951.                     break;
  952.                 case c_AppMachine:
  953.                    
  954.                     if (s_PermAppMachine == null)
  955.                         s_PermAppMachine = new IsolatedStorageFilePermission(IsolatedStorageContainment.ApplicationIsolationByMachine, 0, false);
  956.                     ip = s_PermAppMachine;
  957.                     break;
  958.                 case c_AppUserRoaming:
  959.                    
  960.                     if (s_PermAppUserRoaming == null)
  961.                         s_PermAppUserRoaming = new IsolatedStorageFilePermission(IsolatedStorageContainment.ApplicationIsolationByRoamingUser, 0, false);
  962.                     ip = s_PermAppUserRoaming;
  963.                     break;
  964.                 default:
  965.                    
  966.                     #if _DEBUG
  967.                     BCLDebug.Assert(false, "Invalid scope");
  968.                     break;
  969.                 #endif
  970.             }
  971.            
  972.             ip.Demand();
  973.         }
  974.        
  975.         static internal void VerifyScope(IsolatedStorageScope scope)
  976.         {
  977.             // The only valid ones are the ones that have a helper constant defined above (c_*)
  978.            
  979.             if ((scope == c_Domain) || (scope == c_Assembly) || (scope == c_DomainRoaming) || (scope == c_AssemblyRoaming) || (scope == c_MachineDomain) || (scope == c_MachineAssembly) || (scope == c_AppUser) || (scope == c_AppMachine) || (scope == c_AppUserRoaming))
  980.                 return;
  981.            
  982.             throw new ArgumentException(Environment.GetResourceString("IsolatedStorage_Scope_Invalid"));
  983.         }
  984.        
  985.         internal void SetQuota(PermissionSet psAllowed, PermissionSet psDenied)
  986.         {
  987.             IsolatedStoragePermission ispAllowed;
  988.             IsolatedStoragePermission ispDenied;
  989.            
  990.             ispAllowed = GetPermission(psAllowed);
  991.            
  992.             m_Quota = 0;
  993.            
  994.             if (ispAllowed != null) {
  995.                 if (ispAllowed.IsUnrestricted())
  996.                     m_Quota = Int64.MaxValue;
  997.                 else
  998.                     m_Quota = (ulong)ispAllowed.UserQuota;
  999.             }
  1000.            
  1001.             if (psDenied != null) {
  1002.                 ispDenied = GetPermission(psDenied);
  1003.                
  1004.                 if (ispDenied != null) {
  1005.                     if (ispDenied.IsUnrestricted()) {
  1006.                         m_Quota = 0;
  1007.                     }
  1008.                     else {
  1009.                         ulong denied = (ulong)ispDenied.UserQuota;
  1010.                        
  1011.                         if (denied > m_Quota)
  1012.                             m_Quota = 0;
  1013.                         else
  1014.                             m_Quota -= denied;
  1015.                     }
  1016.                 }
  1017.             }
  1018.            
  1019.             m_ValidQuota = true;
  1020.            
  1021.             #if _DEBUG
  1022.             if (s_fDebug) {
  1023.                 if (s_iDebug >= 1) {
  1024.                     if (psAllowed != null)
  1025.                         Console.WriteLine("Allowed PS : " + psAllowed);
  1026.                     if (psDenied != null)
  1027.                         Console.WriteLine("Denied PS : " + psDenied);
  1028.                 }
  1029.             }
  1030.             #endif
  1031.         }
  1032.        
  1033.         #if _DEBUG
  1034.         private static void DebugLog(object o, MemoryStream ms)
  1035.         {
  1036.             if (s_fDebug) {
  1037.                 if (s_iDebug >= 1)
  1038.                     Console.WriteLine(o.ToString());
  1039.                
  1040.                 if (s_iDebug >= 10) {
  1041.                     byte[] p = ms.GetBuffer();
  1042.                    
  1043.                     for (int _i = 0; _i < ms.Length; ++_i) {
  1044.                         Console.Write(" ");
  1045.                         Console.Write(p[_i]);
  1046.                     }
  1047.                    
  1048.                     Console.WriteLine("");
  1049.                 }
  1050.             }
  1051.         }
  1052.         #endif
  1053.        
  1054.         public abstract void Remove();
  1055.        
  1056.         protected abstract IsolatedStoragePermission GetPermission(PermissionSet ps);
  1057.        
  1058.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  1059.         static internal extern Assembly nGetCaller();
  1060.     }
  1061. }

Developer Fusion